]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


8f0acff84b880b3b0ac2b237c8860aaaf0432183
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2475 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2476 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2477 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2478
2479 #include <wx/quantize.h>
2480
2481 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2482 return wxQuantize::Quantize(src, dest,
2483 //NULL, // palette
2484 desiredNoColours,
2485 NULL, // eightBitData
2486 flags);
2487 }
2488 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2489 if (PyCallable_Check(func)) {
2490 self->Connect(id, lastId, eventType,
2491 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2492 new wxPyCallback(func));
2493 }
2494 else if (func == Py_None) {
2495 self->Disconnect(id, lastId, eventType,
2496 (wxObjectEventFunction)
2497 &wxPyCallback::EventThunker);
2498 }
2499 else {
2500 wxPyBLOCK_THREADS(
2501 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2502 }
2503 }
2504 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2505 return self->Disconnect(id, lastId, eventType,
2506 (wxObjectEventFunction)
2507 &wxPyCallback::EventThunker);
2508 }
2509 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2510 if (_self && _self != Py_None) {
2511 self->SetClientObject(new wxPyOORClientData(_self, incref));
2512 }
2513 else {
2514 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2515 if (data) {
2516 self->SetClientObject(NULL); // This will delete it too
2517 }
2518 }
2519 }
2520
2521 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2522 #if wxUSE_UNICODE
2523 return self->GetUnicodeKey();
2524 #else
2525 return 0;
2526 #endif
2527 }
2528
2529 #if UINT_MAX < LONG_MAX
2530 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2531 #define SWIG_From_unsigned_SS_int SWIG_From_long
2532 /*@@*/
2533 #else
2534 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2536 /*@@*/
2537 #endif
2538
2539
2540 #if UINT_MAX != ULONG_MAX
2541 SWIGINTERN int
2542 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2543 {
2544 const char* errmsg = val ? "unsigned int" : (char*)0;
2545 unsigned long v;
2546 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2547 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2548 if (val) *val = (unsigned int)(v);
2549 return 1;
2550 }
2551 } else {
2552 PyErr_Clear();
2553 }
2554 if (val) {
2555 SWIG_type_error(errmsg, obj);
2556 }
2557 return 0;
2558 }
2559 #else
2560 SWIGINTERNSHORT unsigned int
2561 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2562 {
2563 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2564 }
2565 #endif
2566
2567
2568 SWIGINTERNSHORT unsigned int
2569 SWIG_As_unsigned_SS_int(PyObject* obj)
2570 {
2571 unsigned int v;
2572 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2573 /*
2574 this is needed to make valgrind/purify happier.
2575 */
2576 memset((void*)&v, 0, sizeof(unsigned int));
2577 }
2578 return v;
2579 }
2580
2581
2582 SWIGINTERNSHORT int
2583 SWIG_Check_unsigned_SS_int(PyObject* obj)
2584 {
2585 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2586 }
2587
2588 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2589 self->m_size = size;
2590 }
2591 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2592 int count = self->GetNumberOfFiles();
2593 wxString* files = self->GetFiles();
2594 PyObject* list = PyList_New(count);
2595
2596 if (!list) {
2597 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2598 return NULL;
2599 }
2600
2601 for (int i=0; i<count; i++) {
2602 PyList_SetItem(list, i, wx2PyString(files[i]));
2603 }
2604 return list;
2605 }
2606
2607
2608 static wxPyApp *new_wxPyApp(){
2609 wxPythonApp = new wxPyApp();
2610 return wxPythonApp;
2611 }
2612
2613 void wxApp_CleanUp() {
2614 __wxPyCleanup();
2615 }
2616
2617
2618 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2619
2620
2621 SWIGINTERNSHORT int
2622 SWIG_AsCharPtr(PyObject *obj, char **val)
2623 {
2624 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2625 return 1;
2626 }
2627 if (val) {
2628 PyErr_Clear();
2629 SWIG_type_error("char *", obj);
2630 }
2631 return 0;
2632 }
2633
2634
2635 SWIGINTERN PyObject *
2636 SWIG_FromCharPtr(const char* cptr)
2637 {
2638 if (cptr) {
2639 size_t size = strlen(cptr);
2640 if (size > INT_MAX) {
2641 return SWIG_NewPointerObj((char*)(cptr),
2642 SWIG_TypeQuery("char *"), 0);
2643 } else {
2644 if (size != 0) {
2645 return PyString_FromStringAndSize(cptr, size);
2646 } else {
2647 return PyString_FromString(cptr);
2648 }
2649 }
2650 }
2651 Py_INCREF(Py_None);
2652 return Py_None;
2653 }
2654
2655
2656 #ifdef __WXMAC__
2657
2658 // A dummy class that raises an exception if used...
2659 class wxEventLoop
2660 {
2661 public:
2662 wxEventLoop() { wxPyRaiseNotImplemented(); }
2663 int Run() { return 0; }
2664 void Exit(int rc = 0) {}
2665 bool Pending() const { return false; }
2666 bool Dispatch() { return false; }
2667 bool IsRunning() const { return false; }
2668 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2669 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2670 };
2671
2672 #else
2673
2674 #include <wx/evtloop.h>
2675
2676 #endif
2677
2678
2679
2680 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2681 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2682 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2683 static PyObject *wxWindow_GetChildren(wxWindow *self){
2684 wxWindowList& list = self->GetChildren();
2685 return wxPy_ConvertList(&list);
2686 }
2687 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2688 #if wxUSE_HOTKEY
2689 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2690 #else
2691 return false;
2692 #endif
2693 }
2694 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2695
2696
2697
2698 return false;
2699
2700 }
2701 static long wxWindow_GetHandle(wxWindow *self){
2702 return wxPyGetWinHandle(self);
2703 }
2704 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2705 self->AssociateHandle((WXWidget)handle);
2706 }
2707
2708 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2709 return wxWindow::FindWindowById(id, parent);
2710 }
2711
2712 wxWindow* wxFindWindowByName( const wxString& name,
2713 const wxWindow *parent = NULL ) {
2714 return wxWindow::FindWindowByName(name, parent);
2715 }
2716
2717 wxWindow* wxFindWindowByLabel( const wxString& label,
2718 const wxWindow *parent = NULL ) {
2719 return wxWindow::FindWindowByLabel(label, parent);
2720 }
2721
2722
2723 #ifdef __WXMSW__
2724 #include <wx/msw/private.h> // to get wxGetWindowId
2725 #endif
2726
2727
2728 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2729 #ifdef __WXMSW__
2730 WXHWND hWnd = (WXHWND)_hWnd;
2731 long id = wxGetWindowId(hWnd);
2732 wxWindow* win = new wxWindow;
2733 parent->AddChild(win);
2734 win->SetEventHandler(win);
2735 win->SetHWND(hWnd);
2736 win->SetId(id);
2737 win->SubclassWin(hWnd);
2738 win->AdoptAttributesFromHWND();
2739 win->SetupColours();
2740 return win;
2741 #else
2742 wxPyRaiseNotImplemented();
2743 return NULL;
2744 #endif
2745 }
2746
2747
2748 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2749 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2750 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2751
2752 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2753
2754 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2755 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2756 wxMenuItemList& list = self->GetMenuItems();
2757 return wxPy_ConvertList(&list);
2758 }
2759 static const wxString wxPyControlNameStr(wxControlNameStr);
2760 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2761 if (clientData) {
2762 wxPyClientData* data = new wxPyClientData(clientData);
2763 return self->Append(item, data);
2764 } else
2765 return self->Append(item);
2766 }
2767 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2768 if (clientData) {
2769 wxPyClientData* data = new wxPyClientData(clientData);
2770 return self->Insert(item, pos, data);
2771 } else
2772 return self->Insert(item, pos);
2773 }
2774 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2775 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2776 if (data) {
2777 Py_INCREF(data->m_obj);
2778 return data->m_obj;
2779 } else {
2780 Py_INCREF(Py_None);
2781 return Py_None;
2782 }
2783 }
2784 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2785 wxPyClientData* data = new wxPyClientData(clientData);
2786 self->SetClientObject(n, data);
2787 }
2788
2789
2790 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2791 wxPyUserData* data = NULL;
2792 if ( userData ) {
2793 bool blocked = wxPyBeginBlockThreads();
2794 data = new wxPyUserData(userData);
2795 wxPyEndBlockThreads(blocked);
2796 }
2797 return new wxSizerItem(window, proportion, flag, border, data);
2798 }
2799 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2800 wxPyUserData* data = NULL;
2801 if ( userData ) {
2802 bool blocked = wxPyBeginBlockThreads();
2803 data = new wxPyUserData(userData);
2804 wxPyEndBlockThreads(blocked);
2805 }
2806 return new wxSizerItem(width, height, proportion, flag, border, data);
2807 }
2808 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2809 wxPyUserData* data = NULL;
2810 if ( userData ) {
2811 bool blocked = wxPyBeginBlockThreads();
2812 data = new wxPyUserData(userData);
2813 wxPyEndBlockThreads(blocked);
2814 }
2815 return new wxSizerItem(sizer, proportion, flag, border, data);
2816 }
2817
2818 #include <float.h>
2819 SWIGINTERN int
2820 SWIG_CheckDoubleInRange(double value, double min_value,
2821 double max_value, const char* errmsg)
2822 {
2823 if (value < min_value) {
2824 if (errmsg) {
2825 PyErr_Format(PyExc_OverflowError,
2826 "value %g is less than %s minimum %g",
2827 value, errmsg, min_value);
2828 }
2829 return 0;
2830 } else if (value > max_value) {
2831 if (errmsg) {
2832 PyErr_Format(PyExc_OverflowError,
2833 "value %g is greater than %s maximum %g",
2834 value, errmsg, max_value);
2835 }
2836 return 0;
2837 }
2838 return 1;
2839 }
2840
2841
2842 SWIGINTERN int
2843 SWIG_AsVal_float(PyObject *obj, float *val)
2844 {
2845 const char* errmsg = val ? "float" : (char*)0;
2846 double v;
2847 if (SWIG_AsVal_double(obj, &v)) {
2848 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2849 if (val) *val = (float)(v);
2850 return 1;
2851 } else {
2852 return 0;
2853 }
2854 } else {
2855 PyErr_Clear();
2856 }
2857 if (val) {
2858 SWIG_type_error(errmsg, obj);
2859 }
2860 return 0;
2861 }
2862
2863
2864 SWIGINTERNSHORT float
2865 SWIG_As_float(PyObject* obj)
2866 {
2867 float v;
2868 if (!SWIG_AsVal_float(obj, &v)) {
2869 /*
2870 this is needed to make valgrind/purify happier.
2871 */
2872 memset((void*)&v, 0, sizeof(float));
2873 }
2874 return v;
2875 }
2876
2877
2878 SWIGINTERNSHORT int
2879 SWIG_Check_float(PyObject* obj)
2880 {
2881 return SWIG_AsVal_float(obj, (float*)0);
2882 }
2883
2884
2885 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2886 #define SWIG_From_float PyFloat_FromDouble
2887 /*@@*/
2888
2889 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2890 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2891 if (data) {
2892 Py_INCREF(data->m_obj);
2893 return data->m_obj;
2894 } else {
2895 Py_INCREF(Py_None);
2896 return Py_None;
2897 }
2898 }
2899
2900 // Figure out the type of the sizer item
2901
2902 struct wxPySizerItemInfo {
2903 wxPySizerItemInfo()
2904 : window(NULL), sizer(NULL), gotSize(false),
2905 size(wxDefaultSize), gotPos(false), pos(-1)
2906 {}
2907
2908 wxWindow* window;
2909 wxSizer* sizer;
2910 bool gotSize;
2911 wxSize size;
2912 bool gotPos;
2913 int pos;
2914 };
2915
2916 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2917
2918 wxPySizerItemInfo info;
2919 wxSize size;
2920 wxSize* sizePtr = &size;
2921
2922 // Find out what the type of the item is
2923 // try wxWindow
2924 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2925 PyErr_Clear();
2926 info.window = NULL;
2927
2928 // try wxSizer
2929 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2930 PyErr_Clear();
2931 info.sizer = NULL;
2932
2933 // try wxSize or (w,h)
2934 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2935 info.size = *sizePtr;
2936 info.gotSize = true;
2937 }
2938
2939 // or a single int
2940 if (checkIdx && PyInt_Check(item)) {
2941 info.pos = PyInt_AsLong(item);
2942 info.gotPos = true;
2943 }
2944 }
2945 }
2946
2947 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2948 // no expected type, figure out what kind of error message to generate
2949 if ( !checkSize && !checkIdx )
2950 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2951 else if ( checkSize && !checkIdx )
2952 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2953 else if ( !checkSize && checkIdx)
2954 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2955 else
2956 // can this one happen?
2957 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2958 }
2959
2960 return info;
2961 }
2962
2963 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2964 if (!self->GetClientObject())
2965 self->SetClientObject(new wxPyOORClientData(_self));
2966 }
2967 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2968
2969 wxPyUserData* data = NULL;
2970 bool blocked = wxPyBeginBlockThreads();
2971 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2972 if ( userData && (info.window || info.sizer || info.gotSize) )
2973 data = new wxPyUserData(userData);
2974 wxPyEndBlockThreads(blocked);
2975
2976 // Now call the real Add method if a valid item type was found
2977 if ( info.window )
2978 return self->Add(info.window, proportion, flag, border, data);
2979 else if ( info.sizer )
2980 return self->Add(info.sizer, proportion, flag, border, data);
2981 else if (info.gotSize)
2982 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2983 proportion, flag, border, data);
2984 else
2985 return NULL;
2986 }
2987 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2988
2989 wxPyUserData* data = NULL;
2990 bool blocked = wxPyBeginBlockThreads();
2991 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2992 if ( userData && (info.window || info.sizer || info.gotSize) )
2993 data = new wxPyUserData(userData);
2994 wxPyEndBlockThreads(blocked);
2995
2996 // Now call the real Insert method if a valid item type was found
2997 if ( info.window )
2998 return self->Insert(before, info.window, proportion, flag, border, data);
2999 else if ( info.sizer )
3000 return self->Insert(before, info.sizer, proportion, flag, border, data);
3001 else if (info.gotSize)
3002 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3003 proportion, flag, border, data);
3004 else
3005 return NULL;
3006 }
3007 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3008
3009 wxPyUserData* data = NULL;
3010 bool blocked = wxPyBeginBlockThreads();
3011 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3012 if ( userData && (info.window || info.sizer || info.gotSize) )
3013 data = new wxPyUserData(userData);
3014 wxPyEndBlockThreads(blocked);
3015
3016 // Now call the real Prepend method if a valid item type was found
3017 if ( info.window )
3018 return self->Prepend(info.window, proportion, flag, border, data);
3019 else if ( info.sizer )
3020 return self->Prepend(info.sizer, proportion, flag, border, data);
3021 else if (info.gotSize)
3022 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3023 proportion, flag, border, data);
3024 else
3025 return NULL;
3026 }
3027 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3028 bool blocked = wxPyBeginBlockThreads();
3029 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3030 wxPyEndBlockThreads(blocked);
3031 if ( info.window )
3032 return self->Remove(info.window);
3033 else if ( info.sizer )
3034 return self->Remove(info.sizer);
3035 else if ( info.gotPos )
3036 return self->Remove(info.pos);
3037 else
3038 return false;
3039 }
3040 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3041 bool blocked = wxPyBeginBlockThreads();
3042 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3043 wxPyEndBlockThreads(blocked);
3044 if ( info.window )
3045 return self->Detach(info.window);
3046 else if ( info.sizer )
3047 return self->Detach(info.sizer);
3048 else if ( info.gotPos )
3049 return self->Detach(info.pos);
3050 else
3051 return false;
3052 }
3053 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3054 bool blocked = wxPyBeginBlockThreads();
3055 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3056 wxPyEndBlockThreads(blocked);
3057 if ( info.window )
3058 return self->GetItem(info.window);
3059 else if ( info.sizer )
3060 return self->GetItem(info.sizer);
3061 else if ( info.gotPos )
3062 return self->GetItem(info.pos);
3063 else
3064 return NULL;
3065 }
3066 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3067 bool blocked = wxPyBeginBlockThreads();
3068 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3069 wxPyEndBlockThreads(blocked);
3070 if ( info.window )
3071 self->SetItemMinSize(info.window, size);
3072 else if ( info.sizer )
3073 self->SetItemMinSize(info.sizer, size);
3074 else if ( info.gotPos )
3075 self->SetItemMinSize(info.pos, size);
3076 }
3077 static PyObject *wxSizer_GetChildren(wxSizer *self){
3078 wxSizerItemList& list = self->GetChildren();
3079 return wxPy_ConvertList(&list);
3080 }
3081 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3082 bool blocked = wxPyBeginBlockThreads();
3083 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3084 wxPyEndBlockThreads(blocked);
3085 if ( info.window )
3086 return self->Show(info.window, show, recursive);
3087 else if ( info.sizer )
3088 return self->Show(info.sizer, show, recursive);
3089 else if ( info.gotPos )
3090 return self->Show(info.pos, show);
3091 else
3092 return false;
3093 }
3094 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3095 bool blocked = wxPyBeginBlockThreads();
3096 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3097 wxPyEndBlockThreads(blocked);
3098 if ( info.window )
3099 return self->IsShown(info.window);
3100 else if ( info.sizer )
3101 return self->IsShown(info.sizer);
3102 else if ( info.gotPos )
3103 return self->IsShown(info.pos);
3104 else
3105 return false;
3106 }
3107
3108 // See pyclasses.h
3109 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3110 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3111 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3112
3113
3114
3115
3116 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3117 {
3118 if (source == Py_None) {
3119 **obj = wxGBPosition(-1,-1);
3120 return true;
3121 }
3122 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3123 }
3124
3125 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3126 {
3127 if (source == Py_None) {
3128 **obj = wxGBSpan(-1,-1);
3129 return true;
3130 }
3131 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3132 }
3133
3134
3135 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3136 self->SetRow(row);
3137 self->SetCol(col);
3138 }
3139 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3140 bool blocked = wxPyBeginBlockThreads();
3141 PyObject* tup = PyTuple_New(2);
3142 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3143 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3144 wxPyEndBlockThreads(blocked);
3145 return tup;
3146 }
3147 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3148 self->SetRowspan(rowspan);
3149 self->SetColspan(colspan);
3150 }
3151 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3152 bool blocked = wxPyBeginBlockThreads();
3153 PyObject* tup = PyTuple_New(2);
3154 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3155 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3156 wxPyEndBlockThreads(blocked);
3157 return tup;
3158 }
3159 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3160 wxPyUserData* data = NULL;
3161 if ( userData ) {
3162 bool blocked = wxPyBeginBlockThreads();
3163 data = new wxPyUserData(userData);
3164 wxPyEndBlockThreads(blocked);
3165 }
3166 return new wxGBSizerItem(window, pos, span, flag, border, data);
3167 }
3168 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3169 wxPyUserData* data = NULL;
3170 if ( userData ) {
3171 bool blocked = wxPyBeginBlockThreads();
3172 data = new wxPyUserData(userData);
3173 wxPyEndBlockThreads(blocked);
3174 }
3175 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3176 }
3177 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3178 wxPyUserData* data = NULL;
3179 if ( userData ) {
3180 bool blocked = wxPyBeginBlockThreads();
3181 data = new wxPyUserData(userData);
3182 wxPyEndBlockThreads(blocked);
3183 }
3184 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3185 }
3186 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3187 int row, col;
3188 self->GetEndPos(row, col);
3189 return wxGBPosition(row, col);
3190 }
3191 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3192
3193 wxPyUserData* data = NULL;
3194 bool blocked = wxPyBeginBlockThreads();
3195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3196 if ( userData && (info.window || info.sizer || info.gotSize) )
3197 data = new wxPyUserData(userData);
3198 wxPyEndBlockThreads(blocked);
3199
3200 // Now call the real Add method if a valid item type was found
3201 if ( info.window )
3202 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3203 else if ( info.sizer )
3204 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3205 else if (info.gotSize)
3206 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3207 pos, span, flag, border, data);
3208 return NULL;
3209 }
3210
3211
3212 #ifdef __cplusplus
3213 extern "C" {
3214 #endif
3215 static int _wrap_EmptyString_set(PyObject *) {
3216 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3217 return 1;
3218 }
3219
3220
3221 static PyObject *_wrap_EmptyString_get(void) {
3222 PyObject *pyobj;
3223
3224 {
3225 #if wxUSE_UNICODE
3226 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3227 #else
3228 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3229 #endif
3230 }
3231 return pyobj;
3232 }
3233
3234
3235 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3236 PyObject *resultobj;
3237 wxObject *arg1 = (wxObject *) 0 ;
3238 wxString result;
3239 PyObject * obj0 = 0 ;
3240 char *kwnames[] = {
3241 (char *) "self", NULL
3242 };
3243
3244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3246 if (SWIG_arg_fail(1)) SWIG_fail;
3247 {
3248 PyThreadState* __tstate = wxPyBeginAllowThreads();
3249 result = wxObject_GetClassName(arg1);
3250
3251 wxPyEndAllowThreads(__tstate);
3252 if (PyErr_Occurred()) SWIG_fail;
3253 }
3254 {
3255 #if wxUSE_UNICODE
3256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3257 #else
3258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3259 #endif
3260 }
3261 return resultobj;
3262 fail:
3263 return NULL;
3264 }
3265
3266
3267 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3268 PyObject *resultobj;
3269 wxObject *arg1 = (wxObject *) 0 ;
3270 PyObject * obj0 = 0 ;
3271 char *kwnames[] = {
3272 (char *) "self", NULL
3273 };
3274
3275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3277 if (SWIG_arg_fail(1)) SWIG_fail;
3278 {
3279 PyThreadState* __tstate = wxPyBeginAllowThreads();
3280 wxObject_Destroy(arg1);
3281
3282 wxPyEndAllowThreads(__tstate);
3283 if (PyErr_Occurred()) SWIG_fail;
3284 }
3285 Py_INCREF(Py_None); resultobj = Py_None;
3286 return resultobj;
3287 fail:
3288 return NULL;
3289 }
3290
3291
3292 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3293 PyObject *obj;
3294 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3295 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3296 Py_INCREF(obj);
3297 return Py_BuildValue((char *)"");
3298 }
3299 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3300 PyObject *resultobj;
3301 wxSize *arg1 = (wxSize *) 0 ;
3302 int arg2 ;
3303 PyObject * obj0 = 0 ;
3304 PyObject * obj1 = 0 ;
3305 char *kwnames[] = {
3306 (char *) "self",(char *) "x", NULL
3307 };
3308
3309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3311 if (SWIG_arg_fail(1)) SWIG_fail;
3312 {
3313 arg2 = (int)(SWIG_As_int(obj1));
3314 if (SWIG_arg_fail(2)) SWIG_fail;
3315 }
3316 if (arg1) (arg1)->x = arg2;
3317
3318 Py_INCREF(Py_None); resultobj = Py_None;
3319 return resultobj;
3320 fail:
3321 return NULL;
3322 }
3323
3324
3325 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3326 PyObject *resultobj;
3327 wxSize *arg1 = (wxSize *) 0 ;
3328 int result;
3329 PyObject * obj0 = 0 ;
3330 char *kwnames[] = {
3331 (char *) "self", NULL
3332 };
3333
3334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3336 if (SWIG_arg_fail(1)) SWIG_fail;
3337 result = (int) ((arg1)->x);
3338
3339 {
3340 resultobj = SWIG_From_int((int)(result));
3341 }
3342 return resultobj;
3343 fail:
3344 return NULL;
3345 }
3346
3347
3348 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3349 PyObject *resultobj;
3350 wxSize *arg1 = (wxSize *) 0 ;
3351 int arg2 ;
3352 PyObject * obj0 = 0 ;
3353 PyObject * obj1 = 0 ;
3354 char *kwnames[] = {
3355 (char *) "self",(char *) "y", NULL
3356 };
3357
3358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3360 if (SWIG_arg_fail(1)) SWIG_fail;
3361 {
3362 arg2 = (int)(SWIG_As_int(obj1));
3363 if (SWIG_arg_fail(2)) SWIG_fail;
3364 }
3365 if (arg1) (arg1)->y = arg2;
3366
3367 Py_INCREF(Py_None); resultobj = Py_None;
3368 return resultobj;
3369 fail:
3370 return NULL;
3371 }
3372
3373
3374 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3375 PyObject *resultobj;
3376 wxSize *arg1 = (wxSize *) 0 ;
3377 int result;
3378 PyObject * obj0 = 0 ;
3379 char *kwnames[] = {
3380 (char *) "self", NULL
3381 };
3382
3383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3385 if (SWIG_arg_fail(1)) SWIG_fail;
3386 result = (int) ((arg1)->y);
3387
3388 {
3389 resultobj = SWIG_From_int((int)(result));
3390 }
3391 return resultobj;
3392 fail:
3393 return NULL;
3394 }
3395
3396
3397 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3398 PyObject *resultobj;
3399 int arg1 = (int) 0 ;
3400 int arg2 = (int) 0 ;
3401 wxSize *result;
3402 PyObject * obj0 = 0 ;
3403 PyObject * obj1 = 0 ;
3404 char *kwnames[] = {
3405 (char *) "w",(char *) "h", NULL
3406 };
3407
3408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3409 if (obj0) {
3410 {
3411 arg1 = (int)(SWIG_As_int(obj0));
3412 if (SWIG_arg_fail(1)) SWIG_fail;
3413 }
3414 }
3415 if (obj1) {
3416 {
3417 arg2 = (int)(SWIG_As_int(obj1));
3418 if (SWIG_arg_fail(2)) SWIG_fail;
3419 }
3420 }
3421 {
3422 PyThreadState* __tstate = wxPyBeginAllowThreads();
3423 result = (wxSize *)new wxSize(arg1,arg2);
3424
3425 wxPyEndAllowThreads(__tstate);
3426 if (PyErr_Occurred()) SWIG_fail;
3427 }
3428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3429 return resultobj;
3430 fail:
3431 return NULL;
3432 }
3433
3434
3435 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3436 PyObject *resultobj;
3437 wxSize *arg1 = (wxSize *) 0 ;
3438 PyObject * obj0 = 0 ;
3439 char *kwnames[] = {
3440 (char *) "self", NULL
3441 };
3442
3443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3445 if (SWIG_arg_fail(1)) SWIG_fail;
3446 {
3447 PyThreadState* __tstate = wxPyBeginAllowThreads();
3448 delete arg1;
3449
3450 wxPyEndAllowThreads(__tstate);
3451 if (PyErr_Occurred()) SWIG_fail;
3452 }
3453 Py_INCREF(Py_None); resultobj = Py_None;
3454 return resultobj;
3455 fail:
3456 return NULL;
3457 }
3458
3459
3460 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3461 PyObject *resultobj;
3462 wxSize *arg1 = (wxSize *) 0 ;
3463 wxSize *arg2 = 0 ;
3464 bool result;
3465 wxSize temp2 ;
3466 PyObject * obj0 = 0 ;
3467 PyObject * obj1 = 0 ;
3468 char *kwnames[] = {
3469 (char *) "self",(char *) "sz", NULL
3470 };
3471
3472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3474 if (SWIG_arg_fail(1)) SWIG_fail;
3475 {
3476 arg2 = &temp2;
3477 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3478 }
3479 {
3480 PyThreadState* __tstate = wxPyBeginAllowThreads();
3481 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3482
3483 wxPyEndAllowThreads(__tstate);
3484 if (PyErr_Occurred()) SWIG_fail;
3485 }
3486 {
3487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3488 }
3489 return resultobj;
3490 fail:
3491 return NULL;
3492 }
3493
3494
3495 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3496 PyObject *resultobj;
3497 wxSize *arg1 = (wxSize *) 0 ;
3498 wxSize *arg2 = 0 ;
3499 bool result;
3500 wxSize temp2 ;
3501 PyObject * obj0 = 0 ;
3502 PyObject * obj1 = 0 ;
3503 char *kwnames[] = {
3504 (char *) "self",(char *) "sz", NULL
3505 };
3506
3507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3509 if (SWIG_arg_fail(1)) SWIG_fail;
3510 {
3511 arg2 = &temp2;
3512 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3513 }
3514 {
3515 PyThreadState* __tstate = wxPyBeginAllowThreads();
3516 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3517
3518 wxPyEndAllowThreads(__tstate);
3519 if (PyErr_Occurred()) SWIG_fail;
3520 }
3521 {
3522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3523 }
3524 return resultobj;
3525 fail:
3526 return NULL;
3527 }
3528
3529
3530 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3531 PyObject *resultobj;
3532 wxSize *arg1 = (wxSize *) 0 ;
3533 wxSize *arg2 = 0 ;
3534 wxSize result;
3535 wxSize temp2 ;
3536 PyObject * obj0 = 0 ;
3537 PyObject * obj1 = 0 ;
3538 char *kwnames[] = {
3539 (char *) "self",(char *) "sz", NULL
3540 };
3541
3542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3544 if (SWIG_arg_fail(1)) SWIG_fail;
3545 {
3546 arg2 = &temp2;
3547 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3548 }
3549 {
3550 PyThreadState* __tstate = wxPyBeginAllowThreads();
3551 result = (arg1)->operator +((wxSize const &)*arg2);
3552
3553 wxPyEndAllowThreads(__tstate);
3554 if (PyErr_Occurred()) SWIG_fail;
3555 }
3556 {
3557 wxSize * resultptr;
3558 resultptr = new wxSize((wxSize &)(result));
3559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3560 }
3561 return resultobj;
3562 fail:
3563 return NULL;
3564 }
3565
3566
3567 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3568 PyObject *resultobj;
3569 wxSize *arg1 = (wxSize *) 0 ;
3570 wxSize *arg2 = 0 ;
3571 wxSize result;
3572 wxSize temp2 ;
3573 PyObject * obj0 = 0 ;
3574 PyObject * obj1 = 0 ;
3575 char *kwnames[] = {
3576 (char *) "self",(char *) "sz", NULL
3577 };
3578
3579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3581 if (SWIG_arg_fail(1)) SWIG_fail;
3582 {
3583 arg2 = &temp2;
3584 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3585 }
3586 {
3587 PyThreadState* __tstate = wxPyBeginAllowThreads();
3588 result = (arg1)->operator -((wxSize const &)*arg2);
3589
3590 wxPyEndAllowThreads(__tstate);
3591 if (PyErr_Occurred()) SWIG_fail;
3592 }
3593 {
3594 wxSize * resultptr;
3595 resultptr = new wxSize((wxSize &)(result));
3596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3597 }
3598 return resultobj;
3599 fail:
3600 return NULL;
3601 }
3602
3603
3604 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3605 PyObject *resultobj;
3606 wxSize *arg1 = (wxSize *) 0 ;
3607 wxSize *arg2 = 0 ;
3608 wxSize temp2 ;
3609 PyObject * obj0 = 0 ;
3610 PyObject * obj1 = 0 ;
3611 char *kwnames[] = {
3612 (char *) "self",(char *) "sz", NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3617 if (SWIG_arg_fail(1)) SWIG_fail;
3618 {
3619 arg2 = &temp2;
3620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3621 }
3622 {
3623 PyThreadState* __tstate = wxPyBeginAllowThreads();
3624 (arg1)->IncTo((wxSize const &)*arg2);
3625
3626 wxPyEndAllowThreads(__tstate);
3627 if (PyErr_Occurred()) SWIG_fail;
3628 }
3629 Py_INCREF(Py_None); resultobj = Py_None;
3630 return resultobj;
3631 fail:
3632 return NULL;
3633 }
3634
3635
3636 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3637 PyObject *resultobj;
3638 wxSize *arg1 = (wxSize *) 0 ;
3639 wxSize *arg2 = 0 ;
3640 wxSize temp2 ;
3641 PyObject * obj0 = 0 ;
3642 PyObject * obj1 = 0 ;
3643 char *kwnames[] = {
3644 (char *) "self",(char *) "sz", NULL
3645 };
3646
3647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3649 if (SWIG_arg_fail(1)) SWIG_fail;
3650 {
3651 arg2 = &temp2;
3652 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3653 }
3654 {
3655 PyThreadState* __tstate = wxPyBeginAllowThreads();
3656 (arg1)->DecTo((wxSize const &)*arg2);
3657
3658 wxPyEndAllowThreads(__tstate);
3659 if (PyErr_Occurred()) SWIG_fail;
3660 }
3661 Py_INCREF(Py_None); resultobj = Py_None;
3662 return resultobj;
3663 fail:
3664 return NULL;
3665 }
3666
3667
3668 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3669 PyObject *resultobj;
3670 wxSize *arg1 = (wxSize *) 0 ;
3671 int arg2 ;
3672 int arg3 ;
3673 PyObject * obj0 = 0 ;
3674 PyObject * obj1 = 0 ;
3675 PyObject * obj2 = 0 ;
3676 char *kwnames[] = {
3677 (char *) "self",(char *) "w",(char *) "h", NULL
3678 };
3679
3680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3682 if (SWIG_arg_fail(1)) SWIG_fail;
3683 {
3684 arg2 = (int)(SWIG_As_int(obj1));
3685 if (SWIG_arg_fail(2)) SWIG_fail;
3686 }
3687 {
3688 arg3 = (int)(SWIG_As_int(obj2));
3689 if (SWIG_arg_fail(3)) SWIG_fail;
3690 }
3691 {
3692 PyThreadState* __tstate = wxPyBeginAllowThreads();
3693 (arg1)->Set(arg2,arg3);
3694
3695 wxPyEndAllowThreads(__tstate);
3696 if (PyErr_Occurred()) SWIG_fail;
3697 }
3698 Py_INCREF(Py_None); resultobj = Py_None;
3699 return resultobj;
3700 fail:
3701 return NULL;
3702 }
3703
3704
3705 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3706 PyObject *resultobj;
3707 wxSize *arg1 = (wxSize *) 0 ;
3708 int arg2 ;
3709 PyObject * obj0 = 0 ;
3710 PyObject * obj1 = 0 ;
3711 char *kwnames[] = {
3712 (char *) "self",(char *) "w", NULL
3713 };
3714
3715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3717 if (SWIG_arg_fail(1)) SWIG_fail;
3718 {
3719 arg2 = (int)(SWIG_As_int(obj1));
3720 if (SWIG_arg_fail(2)) SWIG_fail;
3721 }
3722 {
3723 PyThreadState* __tstate = wxPyBeginAllowThreads();
3724 (arg1)->SetWidth(arg2);
3725
3726 wxPyEndAllowThreads(__tstate);
3727 if (PyErr_Occurred()) SWIG_fail;
3728 }
3729 Py_INCREF(Py_None); resultobj = Py_None;
3730 return resultobj;
3731 fail:
3732 return NULL;
3733 }
3734
3735
3736 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3737 PyObject *resultobj;
3738 wxSize *arg1 = (wxSize *) 0 ;
3739 int arg2 ;
3740 PyObject * obj0 = 0 ;
3741 PyObject * obj1 = 0 ;
3742 char *kwnames[] = {
3743 (char *) "self",(char *) "h", NULL
3744 };
3745
3746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3748 if (SWIG_arg_fail(1)) SWIG_fail;
3749 {
3750 arg2 = (int)(SWIG_As_int(obj1));
3751 if (SWIG_arg_fail(2)) SWIG_fail;
3752 }
3753 {
3754 PyThreadState* __tstate = wxPyBeginAllowThreads();
3755 (arg1)->SetHeight(arg2);
3756
3757 wxPyEndAllowThreads(__tstate);
3758 if (PyErr_Occurred()) SWIG_fail;
3759 }
3760 Py_INCREF(Py_None); resultobj = Py_None;
3761 return resultobj;
3762 fail:
3763 return NULL;
3764 }
3765
3766
3767 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3768 PyObject *resultobj;
3769 wxSize *arg1 = (wxSize *) 0 ;
3770 int result;
3771 PyObject * obj0 = 0 ;
3772 char *kwnames[] = {
3773 (char *) "self", NULL
3774 };
3775
3776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3778 if (SWIG_arg_fail(1)) SWIG_fail;
3779 {
3780 PyThreadState* __tstate = wxPyBeginAllowThreads();
3781 result = (int)((wxSize const *)arg1)->GetWidth();
3782
3783 wxPyEndAllowThreads(__tstate);
3784 if (PyErr_Occurred()) SWIG_fail;
3785 }
3786 {
3787 resultobj = SWIG_From_int((int)(result));
3788 }
3789 return resultobj;
3790 fail:
3791 return NULL;
3792 }
3793
3794
3795 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3796 PyObject *resultobj;
3797 wxSize *arg1 = (wxSize *) 0 ;
3798 int result;
3799 PyObject * obj0 = 0 ;
3800 char *kwnames[] = {
3801 (char *) "self", NULL
3802 };
3803
3804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3806 if (SWIG_arg_fail(1)) SWIG_fail;
3807 {
3808 PyThreadState* __tstate = wxPyBeginAllowThreads();
3809 result = (int)((wxSize const *)arg1)->GetHeight();
3810
3811 wxPyEndAllowThreads(__tstate);
3812 if (PyErr_Occurred()) SWIG_fail;
3813 }
3814 {
3815 resultobj = SWIG_From_int((int)(result));
3816 }
3817 return resultobj;
3818 fail:
3819 return NULL;
3820 }
3821
3822
3823 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3824 PyObject *resultobj;
3825 wxSize *arg1 = (wxSize *) 0 ;
3826 bool result;
3827 PyObject * obj0 = 0 ;
3828 char *kwnames[] = {
3829 (char *) "self", NULL
3830 };
3831
3832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3834 if (SWIG_arg_fail(1)) SWIG_fail;
3835 {
3836 PyThreadState* __tstate = wxPyBeginAllowThreads();
3837 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3838
3839 wxPyEndAllowThreads(__tstate);
3840 if (PyErr_Occurred()) SWIG_fail;
3841 }
3842 {
3843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3844 }
3845 return resultobj;
3846 fail:
3847 return NULL;
3848 }
3849
3850
3851 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3852 PyObject *resultobj;
3853 wxSize *arg1 = (wxSize *) 0 ;
3854 wxSize *arg2 = 0 ;
3855 wxSize temp2 ;
3856 PyObject * obj0 = 0 ;
3857 PyObject * obj1 = 0 ;
3858 char *kwnames[] = {
3859 (char *) "self",(char *) "size", NULL
3860 };
3861
3862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3864 if (SWIG_arg_fail(1)) SWIG_fail;
3865 {
3866 arg2 = &temp2;
3867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3868 }
3869 {
3870 PyThreadState* __tstate = wxPyBeginAllowThreads();
3871 (arg1)->SetDefaults((wxSize const &)*arg2);
3872
3873 wxPyEndAllowThreads(__tstate);
3874 if (PyErr_Occurred()) SWIG_fail;
3875 }
3876 Py_INCREF(Py_None); resultobj = Py_None;
3877 return resultobj;
3878 fail:
3879 return NULL;
3880 }
3881
3882
3883 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3884 PyObject *resultobj;
3885 wxSize *arg1 = (wxSize *) 0 ;
3886 PyObject *result;
3887 PyObject * obj0 = 0 ;
3888 char *kwnames[] = {
3889 (char *) "self", NULL
3890 };
3891
3892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3894 if (SWIG_arg_fail(1)) SWIG_fail;
3895 {
3896 PyThreadState* __tstate = wxPyBeginAllowThreads();
3897 result = (PyObject *)wxSize_Get(arg1);
3898
3899 wxPyEndAllowThreads(__tstate);
3900 if (PyErr_Occurred()) SWIG_fail;
3901 }
3902 resultobj = result;
3903 return resultobj;
3904 fail:
3905 return NULL;
3906 }
3907
3908
3909 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3910 PyObject *obj;
3911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3912 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3913 Py_INCREF(obj);
3914 return Py_BuildValue((char *)"");
3915 }
3916 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3917 PyObject *resultobj;
3918 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3919 double arg2 ;
3920 PyObject * obj0 = 0 ;
3921 PyObject * obj1 = 0 ;
3922 char *kwnames[] = {
3923 (char *) "self",(char *) "x", NULL
3924 };
3925
3926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3928 if (SWIG_arg_fail(1)) SWIG_fail;
3929 {
3930 arg2 = (double)(SWIG_As_double(obj1));
3931 if (SWIG_arg_fail(2)) SWIG_fail;
3932 }
3933 if (arg1) (arg1)->x = arg2;
3934
3935 Py_INCREF(Py_None); resultobj = Py_None;
3936 return resultobj;
3937 fail:
3938 return NULL;
3939 }
3940
3941
3942 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3943 PyObject *resultobj;
3944 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3945 double result;
3946 PyObject * obj0 = 0 ;
3947 char *kwnames[] = {
3948 (char *) "self", NULL
3949 };
3950
3951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3953 if (SWIG_arg_fail(1)) SWIG_fail;
3954 result = (double) ((arg1)->x);
3955
3956 {
3957 resultobj = SWIG_From_double((double)(result));
3958 }
3959 return resultobj;
3960 fail:
3961 return NULL;
3962 }
3963
3964
3965 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3966 PyObject *resultobj;
3967 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3968 double arg2 ;
3969 PyObject * obj0 = 0 ;
3970 PyObject * obj1 = 0 ;
3971 char *kwnames[] = {
3972 (char *) "self",(char *) "y", NULL
3973 };
3974
3975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3977 if (SWIG_arg_fail(1)) SWIG_fail;
3978 {
3979 arg2 = (double)(SWIG_As_double(obj1));
3980 if (SWIG_arg_fail(2)) SWIG_fail;
3981 }
3982 if (arg1) (arg1)->y = arg2;
3983
3984 Py_INCREF(Py_None); resultobj = Py_None;
3985 return resultobj;
3986 fail:
3987 return NULL;
3988 }
3989
3990
3991 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3992 PyObject *resultobj;
3993 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3994 double result;
3995 PyObject * obj0 = 0 ;
3996 char *kwnames[] = {
3997 (char *) "self", NULL
3998 };
3999
4000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4002 if (SWIG_arg_fail(1)) SWIG_fail;
4003 result = (double) ((arg1)->y);
4004
4005 {
4006 resultobj = SWIG_From_double((double)(result));
4007 }
4008 return resultobj;
4009 fail:
4010 return NULL;
4011 }
4012
4013
4014 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4015 PyObject *resultobj;
4016 double arg1 = (double) 0.0 ;
4017 double arg2 = (double) 0.0 ;
4018 wxRealPoint *result;
4019 PyObject * obj0 = 0 ;
4020 PyObject * obj1 = 0 ;
4021 char *kwnames[] = {
4022 (char *) "x",(char *) "y", NULL
4023 };
4024
4025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4026 if (obj0) {
4027 {
4028 arg1 = (double)(SWIG_As_double(obj0));
4029 if (SWIG_arg_fail(1)) SWIG_fail;
4030 }
4031 }
4032 if (obj1) {
4033 {
4034 arg2 = (double)(SWIG_As_double(obj1));
4035 if (SWIG_arg_fail(2)) SWIG_fail;
4036 }
4037 }
4038 {
4039 PyThreadState* __tstate = wxPyBeginAllowThreads();
4040 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4041
4042 wxPyEndAllowThreads(__tstate);
4043 if (PyErr_Occurred()) SWIG_fail;
4044 }
4045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4046 return resultobj;
4047 fail:
4048 return NULL;
4049 }
4050
4051
4052 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4053 PyObject *resultobj;
4054 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4055 PyObject * obj0 = 0 ;
4056 char *kwnames[] = {
4057 (char *) "self", NULL
4058 };
4059
4060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4062 if (SWIG_arg_fail(1)) SWIG_fail;
4063 {
4064 PyThreadState* __tstate = wxPyBeginAllowThreads();
4065 delete arg1;
4066
4067 wxPyEndAllowThreads(__tstate);
4068 if (PyErr_Occurred()) SWIG_fail;
4069 }
4070 Py_INCREF(Py_None); resultobj = Py_None;
4071 return resultobj;
4072 fail:
4073 return NULL;
4074 }
4075
4076
4077 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj;
4079 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4080 wxRealPoint *arg2 = 0 ;
4081 bool result;
4082 wxRealPoint temp2 ;
4083 PyObject * obj0 = 0 ;
4084 PyObject * obj1 = 0 ;
4085 char *kwnames[] = {
4086 (char *) "self",(char *) "pt", NULL
4087 };
4088
4089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4091 if (SWIG_arg_fail(1)) SWIG_fail;
4092 {
4093 arg2 = &temp2;
4094 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4095 }
4096 {
4097 PyThreadState* __tstate = wxPyBeginAllowThreads();
4098 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4099
4100 wxPyEndAllowThreads(__tstate);
4101 if (PyErr_Occurred()) SWIG_fail;
4102 }
4103 {
4104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4105 }
4106 return resultobj;
4107 fail:
4108 return NULL;
4109 }
4110
4111
4112 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4113 PyObject *resultobj;
4114 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4115 wxRealPoint *arg2 = 0 ;
4116 bool result;
4117 wxRealPoint temp2 ;
4118 PyObject * obj0 = 0 ;
4119 PyObject * obj1 = 0 ;
4120 char *kwnames[] = {
4121 (char *) "self",(char *) "pt", NULL
4122 };
4123
4124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4126 if (SWIG_arg_fail(1)) SWIG_fail;
4127 {
4128 arg2 = &temp2;
4129 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4130 }
4131 {
4132 PyThreadState* __tstate = wxPyBeginAllowThreads();
4133 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4134
4135 wxPyEndAllowThreads(__tstate);
4136 if (PyErr_Occurred()) SWIG_fail;
4137 }
4138 {
4139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4140 }
4141 return resultobj;
4142 fail:
4143 return NULL;
4144 }
4145
4146
4147 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4148 PyObject *resultobj;
4149 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4150 wxRealPoint *arg2 = 0 ;
4151 wxRealPoint result;
4152 wxRealPoint temp2 ;
4153 PyObject * obj0 = 0 ;
4154 PyObject * obj1 = 0 ;
4155 char *kwnames[] = {
4156 (char *) "self",(char *) "pt", NULL
4157 };
4158
4159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4161 if (SWIG_arg_fail(1)) SWIG_fail;
4162 {
4163 arg2 = &temp2;
4164 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4165 }
4166 {
4167 PyThreadState* __tstate = wxPyBeginAllowThreads();
4168 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4169
4170 wxPyEndAllowThreads(__tstate);
4171 if (PyErr_Occurred()) SWIG_fail;
4172 }
4173 {
4174 wxRealPoint * resultptr;
4175 resultptr = new wxRealPoint((wxRealPoint &)(result));
4176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4177 }
4178 return resultobj;
4179 fail:
4180 return NULL;
4181 }
4182
4183
4184 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4185 PyObject *resultobj;
4186 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4187 wxRealPoint *arg2 = 0 ;
4188 wxRealPoint result;
4189 wxRealPoint temp2 ;
4190 PyObject * obj0 = 0 ;
4191 PyObject * obj1 = 0 ;
4192 char *kwnames[] = {
4193 (char *) "self",(char *) "pt", NULL
4194 };
4195
4196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4198 if (SWIG_arg_fail(1)) SWIG_fail;
4199 {
4200 arg2 = &temp2;
4201 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4202 }
4203 {
4204 PyThreadState* __tstate = wxPyBeginAllowThreads();
4205 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4206
4207 wxPyEndAllowThreads(__tstate);
4208 if (PyErr_Occurred()) SWIG_fail;
4209 }
4210 {
4211 wxRealPoint * resultptr;
4212 resultptr = new wxRealPoint((wxRealPoint &)(result));
4213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4214 }
4215 return resultobj;
4216 fail:
4217 return NULL;
4218 }
4219
4220
4221 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4222 PyObject *resultobj;
4223 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4224 double arg2 ;
4225 double arg3 ;
4226 PyObject * obj0 = 0 ;
4227 PyObject * obj1 = 0 ;
4228 PyObject * obj2 = 0 ;
4229 char *kwnames[] = {
4230 (char *) "self",(char *) "x",(char *) "y", NULL
4231 };
4232
4233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4235 if (SWIG_arg_fail(1)) SWIG_fail;
4236 {
4237 arg2 = (double)(SWIG_As_double(obj1));
4238 if (SWIG_arg_fail(2)) SWIG_fail;
4239 }
4240 {
4241 arg3 = (double)(SWIG_As_double(obj2));
4242 if (SWIG_arg_fail(3)) SWIG_fail;
4243 }
4244 {
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 wxRealPoint_Set(arg1,arg2,arg3);
4247
4248 wxPyEndAllowThreads(__tstate);
4249 if (PyErr_Occurred()) SWIG_fail;
4250 }
4251 Py_INCREF(Py_None); resultobj = Py_None;
4252 return resultobj;
4253 fail:
4254 return NULL;
4255 }
4256
4257
4258 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4259 PyObject *resultobj;
4260 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4261 PyObject *result;
4262 PyObject * obj0 = 0 ;
4263 char *kwnames[] = {
4264 (char *) "self", NULL
4265 };
4266
4267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4269 if (SWIG_arg_fail(1)) SWIG_fail;
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 result = (PyObject *)wxRealPoint_Get(arg1);
4273
4274 wxPyEndAllowThreads(__tstate);
4275 if (PyErr_Occurred()) SWIG_fail;
4276 }
4277 resultobj = result;
4278 return resultobj;
4279 fail:
4280 return NULL;
4281 }
4282
4283
4284 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4285 PyObject *obj;
4286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4287 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4288 Py_INCREF(obj);
4289 return Py_BuildValue((char *)"");
4290 }
4291 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4292 PyObject *resultobj;
4293 wxPoint *arg1 = (wxPoint *) 0 ;
4294 int arg2 ;
4295 PyObject * obj0 = 0 ;
4296 PyObject * obj1 = 0 ;
4297 char *kwnames[] = {
4298 (char *) "self",(char *) "x", NULL
4299 };
4300
4301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4303 if (SWIG_arg_fail(1)) SWIG_fail;
4304 {
4305 arg2 = (int)(SWIG_As_int(obj1));
4306 if (SWIG_arg_fail(2)) SWIG_fail;
4307 }
4308 if (arg1) (arg1)->x = arg2;
4309
4310 Py_INCREF(Py_None); resultobj = Py_None;
4311 return resultobj;
4312 fail:
4313 return NULL;
4314 }
4315
4316
4317 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4318 PyObject *resultobj;
4319 wxPoint *arg1 = (wxPoint *) 0 ;
4320 int result;
4321 PyObject * obj0 = 0 ;
4322 char *kwnames[] = {
4323 (char *) "self", NULL
4324 };
4325
4326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4328 if (SWIG_arg_fail(1)) SWIG_fail;
4329 result = (int) ((arg1)->x);
4330
4331 {
4332 resultobj = SWIG_From_int((int)(result));
4333 }
4334 return resultobj;
4335 fail:
4336 return NULL;
4337 }
4338
4339
4340 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4341 PyObject *resultobj;
4342 wxPoint *arg1 = (wxPoint *) 0 ;
4343 int arg2 ;
4344 PyObject * obj0 = 0 ;
4345 PyObject * obj1 = 0 ;
4346 char *kwnames[] = {
4347 (char *) "self",(char *) "y", NULL
4348 };
4349
4350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4352 if (SWIG_arg_fail(1)) SWIG_fail;
4353 {
4354 arg2 = (int)(SWIG_As_int(obj1));
4355 if (SWIG_arg_fail(2)) SWIG_fail;
4356 }
4357 if (arg1) (arg1)->y = arg2;
4358
4359 Py_INCREF(Py_None); resultobj = Py_None;
4360 return resultobj;
4361 fail:
4362 return NULL;
4363 }
4364
4365
4366 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4367 PyObject *resultobj;
4368 wxPoint *arg1 = (wxPoint *) 0 ;
4369 int result;
4370 PyObject * obj0 = 0 ;
4371 char *kwnames[] = {
4372 (char *) "self", NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4377 if (SWIG_arg_fail(1)) SWIG_fail;
4378 result = (int) ((arg1)->y);
4379
4380 {
4381 resultobj = SWIG_From_int((int)(result));
4382 }
4383 return resultobj;
4384 fail:
4385 return NULL;
4386 }
4387
4388
4389 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4390 PyObject *resultobj;
4391 int arg1 = (int) 0 ;
4392 int arg2 = (int) 0 ;
4393 wxPoint *result;
4394 PyObject * obj0 = 0 ;
4395 PyObject * obj1 = 0 ;
4396 char *kwnames[] = {
4397 (char *) "x",(char *) "y", NULL
4398 };
4399
4400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4401 if (obj0) {
4402 {
4403 arg1 = (int)(SWIG_As_int(obj0));
4404 if (SWIG_arg_fail(1)) SWIG_fail;
4405 }
4406 }
4407 if (obj1) {
4408 {
4409 arg2 = (int)(SWIG_As_int(obj1));
4410 if (SWIG_arg_fail(2)) SWIG_fail;
4411 }
4412 }
4413 {
4414 PyThreadState* __tstate = wxPyBeginAllowThreads();
4415 result = (wxPoint *)new wxPoint(arg1,arg2);
4416
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj;
4429 wxPoint *arg1 = (wxPoint *) 0 ;
4430 PyObject * obj0 = 0 ;
4431 char *kwnames[] = {
4432 (char *) "self", NULL
4433 };
4434
4435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4437 if (SWIG_arg_fail(1)) SWIG_fail;
4438 {
4439 PyThreadState* __tstate = wxPyBeginAllowThreads();
4440 delete arg1;
4441
4442 wxPyEndAllowThreads(__tstate);
4443 if (PyErr_Occurred()) SWIG_fail;
4444 }
4445 Py_INCREF(Py_None); resultobj = Py_None;
4446 return resultobj;
4447 fail:
4448 return NULL;
4449 }
4450
4451
4452 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4453 PyObject *resultobj;
4454 wxPoint *arg1 = (wxPoint *) 0 ;
4455 wxPoint *arg2 = 0 ;
4456 bool result;
4457 wxPoint temp2 ;
4458 PyObject * obj0 = 0 ;
4459 PyObject * obj1 = 0 ;
4460 char *kwnames[] = {
4461 (char *) "self",(char *) "pt", NULL
4462 };
4463
4464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4466 if (SWIG_arg_fail(1)) SWIG_fail;
4467 {
4468 arg2 = &temp2;
4469 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4470 }
4471 {
4472 PyThreadState* __tstate = wxPyBeginAllowThreads();
4473 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4474
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 {
4479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4480 }
4481 return resultobj;
4482 fail:
4483 return NULL;
4484 }
4485
4486
4487 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4488 PyObject *resultobj;
4489 wxPoint *arg1 = (wxPoint *) 0 ;
4490 wxPoint *arg2 = 0 ;
4491 bool result;
4492 wxPoint temp2 ;
4493 PyObject * obj0 = 0 ;
4494 PyObject * obj1 = 0 ;
4495 char *kwnames[] = {
4496 (char *) "self",(char *) "pt", NULL
4497 };
4498
4499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4501 if (SWIG_arg_fail(1)) SWIG_fail;
4502 {
4503 arg2 = &temp2;
4504 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4505 }
4506 {
4507 PyThreadState* __tstate = wxPyBeginAllowThreads();
4508 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4509
4510 wxPyEndAllowThreads(__tstate);
4511 if (PyErr_Occurred()) SWIG_fail;
4512 }
4513 {
4514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4515 }
4516 return resultobj;
4517 fail:
4518 return NULL;
4519 }
4520
4521
4522 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4523 PyObject *resultobj;
4524 wxPoint *arg1 = (wxPoint *) 0 ;
4525 wxPoint *arg2 = 0 ;
4526 wxPoint result;
4527 wxPoint temp2 ;
4528 PyObject * obj0 = 0 ;
4529 PyObject * obj1 = 0 ;
4530 char *kwnames[] = {
4531 (char *) "self",(char *) "pt", NULL
4532 };
4533
4534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4536 if (SWIG_arg_fail(1)) SWIG_fail;
4537 {
4538 arg2 = &temp2;
4539 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4540 }
4541 {
4542 PyThreadState* __tstate = wxPyBeginAllowThreads();
4543 result = (arg1)->operator +((wxPoint const &)*arg2);
4544
4545 wxPyEndAllowThreads(__tstate);
4546 if (PyErr_Occurred()) SWIG_fail;
4547 }
4548 {
4549 wxPoint * resultptr;
4550 resultptr = new wxPoint((wxPoint &)(result));
4551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4552 }
4553 return resultobj;
4554 fail:
4555 return NULL;
4556 }
4557
4558
4559 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4560 PyObject *resultobj;
4561 wxPoint *arg1 = (wxPoint *) 0 ;
4562 wxPoint *arg2 = 0 ;
4563 wxPoint result;
4564 wxPoint temp2 ;
4565 PyObject * obj0 = 0 ;
4566 PyObject * obj1 = 0 ;
4567 char *kwnames[] = {
4568 (char *) "self",(char *) "pt", NULL
4569 };
4570
4571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4573 if (SWIG_arg_fail(1)) SWIG_fail;
4574 {
4575 arg2 = &temp2;
4576 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4577 }
4578 {
4579 PyThreadState* __tstate = wxPyBeginAllowThreads();
4580 result = (arg1)->operator -((wxPoint const &)*arg2);
4581
4582 wxPyEndAllowThreads(__tstate);
4583 if (PyErr_Occurred()) SWIG_fail;
4584 }
4585 {
4586 wxPoint * resultptr;
4587 resultptr = new wxPoint((wxPoint &)(result));
4588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4589 }
4590 return resultobj;
4591 fail:
4592 return NULL;
4593 }
4594
4595
4596 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4597 PyObject *resultobj;
4598 wxPoint *arg1 = (wxPoint *) 0 ;
4599 wxPoint *arg2 = 0 ;
4600 wxPoint *result;
4601 wxPoint temp2 ;
4602 PyObject * obj0 = 0 ;
4603 PyObject * obj1 = 0 ;
4604 char *kwnames[] = {
4605 (char *) "self",(char *) "pt", NULL
4606 };
4607
4608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4610 if (SWIG_arg_fail(1)) SWIG_fail;
4611 {
4612 arg2 = &temp2;
4613 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4614 }
4615 {
4616 PyThreadState* __tstate = wxPyBeginAllowThreads();
4617 {
4618 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4619 result = (wxPoint *) &_result_ref;
4620 }
4621
4622 wxPyEndAllowThreads(__tstate);
4623 if (PyErr_Occurred()) SWIG_fail;
4624 }
4625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4633 PyObject *resultobj;
4634 wxPoint *arg1 = (wxPoint *) 0 ;
4635 wxPoint *arg2 = 0 ;
4636 wxPoint *result;
4637 wxPoint temp2 ;
4638 PyObject * obj0 = 0 ;
4639 PyObject * obj1 = 0 ;
4640 char *kwnames[] = {
4641 (char *) "self",(char *) "pt", NULL
4642 };
4643
4644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4646 if (SWIG_arg_fail(1)) SWIG_fail;
4647 {
4648 arg2 = &temp2;
4649 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4650 }
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 {
4654 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4655 result = (wxPoint *) &_result_ref;
4656 }
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj;
4670 wxPoint *arg1 = (wxPoint *) 0 ;
4671 long arg2 ;
4672 long arg3 ;
4673 PyObject * obj0 = 0 ;
4674 PyObject * obj1 = 0 ;
4675 PyObject * obj2 = 0 ;
4676 char *kwnames[] = {
4677 (char *) "self",(char *) "x",(char *) "y", NULL
4678 };
4679
4680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4682 if (SWIG_arg_fail(1)) SWIG_fail;
4683 {
4684 arg2 = (long)(SWIG_As_long(obj1));
4685 if (SWIG_arg_fail(2)) SWIG_fail;
4686 }
4687 {
4688 arg3 = (long)(SWIG_As_long(obj2));
4689 if (SWIG_arg_fail(3)) SWIG_fail;
4690 }
4691 {
4692 PyThreadState* __tstate = wxPyBeginAllowThreads();
4693 wxPoint_Set(arg1,arg2,arg3);
4694
4695 wxPyEndAllowThreads(__tstate);
4696 if (PyErr_Occurred()) SWIG_fail;
4697 }
4698 Py_INCREF(Py_None); resultobj = Py_None;
4699 return resultobj;
4700 fail:
4701 return NULL;
4702 }
4703
4704
4705 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4706 PyObject *resultobj;
4707 wxPoint *arg1 = (wxPoint *) 0 ;
4708 PyObject *result;
4709 PyObject * obj0 = 0 ;
4710 char *kwnames[] = {
4711 (char *) "self", NULL
4712 };
4713
4714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4716 if (SWIG_arg_fail(1)) SWIG_fail;
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 result = (PyObject *)wxPoint_Get(arg1);
4720
4721 wxPyEndAllowThreads(__tstate);
4722 if (PyErr_Occurred()) SWIG_fail;
4723 }
4724 resultobj = result;
4725 return resultobj;
4726 fail:
4727 return NULL;
4728 }
4729
4730
4731 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4732 PyObject *obj;
4733 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4734 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4735 Py_INCREF(obj);
4736 return Py_BuildValue((char *)"");
4737 }
4738 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4739 PyObject *resultobj;
4740 int arg1 = (int) 0 ;
4741 int arg2 = (int) 0 ;
4742 int arg3 = (int) 0 ;
4743 int arg4 = (int) 0 ;
4744 wxRect *result;
4745 PyObject * obj0 = 0 ;
4746 PyObject * obj1 = 0 ;
4747 PyObject * obj2 = 0 ;
4748 PyObject * obj3 = 0 ;
4749 char *kwnames[] = {
4750 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4751 };
4752
4753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4754 if (obj0) {
4755 {
4756 arg1 = (int)(SWIG_As_int(obj0));
4757 if (SWIG_arg_fail(1)) SWIG_fail;
4758 }
4759 }
4760 if (obj1) {
4761 {
4762 arg2 = (int)(SWIG_As_int(obj1));
4763 if (SWIG_arg_fail(2)) SWIG_fail;
4764 }
4765 }
4766 if (obj2) {
4767 {
4768 arg3 = (int)(SWIG_As_int(obj2));
4769 if (SWIG_arg_fail(3)) SWIG_fail;
4770 }
4771 }
4772 if (obj3) {
4773 {
4774 arg4 = (int)(SWIG_As_int(obj3));
4775 if (SWIG_arg_fail(4)) SWIG_fail;
4776 }
4777 }
4778 {
4779 PyThreadState* __tstate = wxPyBeginAllowThreads();
4780 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4781
4782 wxPyEndAllowThreads(__tstate);
4783 if (PyErr_Occurred()) SWIG_fail;
4784 }
4785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4786 return resultobj;
4787 fail:
4788 return NULL;
4789 }
4790
4791
4792 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj;
4794 wxPoint *arg1 = 0 ;
4795 wxPoint *arg2 = 0 ;
4796 wxRect *result;
4797 wxPoint temp1 ;
4798 wxPoint temp2 ;
4799 PyObject * obj0 = 0 ;
4800 PyObject * obj1 = 0 ;
4801 char *kwnames[] = {
4802 (char *) "topLeft",(char *) "bottomRight", NULL
4803 };
4804
4805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4806 {
4807 arg1 = &temp1;
4808 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4809 }
4810 {
4811 arg2 = &temp2;
4812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4813 }
4814 {
4815 PyThreadState* __tstate = wxPyBeginAllowThreads();
4816 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4817
4818 wxPyEndAllowThreads(__tstate);
4819 if (PyErr_Occurred()) SWIG_fail;
4820 }
4821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4829 PyObject *resultobj;
4830 wxPoint *arg1 = 0 ;
4831 wxSize *arg2 = 0 ;
4832 wxRect *result;
4833 wxPoint temp1 ;
4834 wxSize temp2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char *kwnames[] = {
4838 (char *) "pos",(char *) "size", NULL
4839 };
4840
4841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4842 {
4843 arg1 = &temp1;
4844 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4845 }
4846 {
4847 arg2 = &temp2;
4848 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4849 }
4850 {
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4853
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj;
4866 wxSize *arg1 = 0 ;
4867 wxRect *result;
4868 wxSize temp1 ;
4869 PyObject * obj0 = 0 ;
4870 char *kwnames[] = {
4871 (char *) "size", NULL
4872 };
4873
4874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4875 {
4876 arg1 = &temp1;
4877 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4878 }
4879 {
4880 PyThreadState* __tstate = wxPyBeginAllowThreads();
4881 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4882
4883 wxPyEndAllowThreads(__tstate);
4884 if (PyErr_Occurred()) SWIG_fail;
4885 }
4886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4887 return resultobj;
4888 fail:
4889 return NULL;
4890 }
4891
4892
4893 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4894 PyObject *resultobj;
4895 wxRect *arg1 = (wxRect *) 0 ;
4896 PyObject * obj0 = 0 ;
4897 char *kwnames[] = {
4898 (char *) "self", NULL
4899 };
4900
4901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4903 if (SWIG_arg_fail(1)) SWIG_fail;
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 delete arg1;
4907
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 Py_INCREF(Py_None); resultobj = Py_None;
4912 return resultobj;
4913 fail:
4914 return NULL;
4915 }
4916
4917
4918 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4919 PyObject *resultobj;
4920 wxRect *arg1 = (wxRect *) 0 ;
4921 int result;
4922 PyObject * obj0 = 0 ;
4923 char *kwnames[] = {
4924 (char *) "self", NULL
4925 };
4926
4927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4929 if (SWIG_arg_fail(1)) SWIG_fail;
4930 {
4931 PyThreadState* __tstate = wxPyBeginAllowThreads();
4932 result = (int)((wxRect const *)arg1)->GetX();
4933
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 {
4938 resultobj = SWIG_From_int((int)(result));
4939 }
4940 return resultobj;
4941 fail:
4942 return NULL;
4943 }
4944
4945
4946 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4947 PyObject *resultobj;
4948 wxRect *arg1 = (wxRect *) 0 ;
4949 int arg2 ;
4950 PyObject * obj0 = 0 ;
4951 PyObject * obj1 = 0 ;
4952 char *kwnames[] = {
4953 (char *) "self",(char *) "x", NULL
4954 };
4955
4956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4958 if (SWIG_arg_fail(1)) SWIG_fail;
4959 {
4960 arg2 = (int)(SWIG_As_int(obj1));
4961 if (SWIG_arg_fail(2)) SWIG_fail;
4962 }
4963 {
4964 PyThreadState* __tstate = wxPyBeginAllowThreads();
4965 (arg1)->SetX(arg2);
4966
4967 wxPyEndAllowThreads(__tstate);
4968 if (PyErr_Occurred()) SWIG_fail;
4969 }
4970 Py_INCREF(Py_None); resultobj = Py_None;
4971 return resultobj;
4972 fail:
4973 return NULL;
4974 }
4975
4976
4977 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4978 PyObject *resultobj;
4979 wxRect *arg1 = (wxRect *) 0 ;
4980 int result;
4981 PyObject * obj0 = 0 ;
4982 char *kwnames[] = {
4983 (char *) "self", NULL
4984 };
4985
4986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4988 if (SWIG_arg_fail(1)) SWIG_fail;
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 result = (int)(arg1)->GetY();
4992
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 {
4997 resultobj = SWIG_From_int((int)(result));
4998 }
4999 return resultobj;
5000 fail:
5001 return NULL;
5002 }
5003
5004
5005 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5006 PyObject *resultobj;
5007 wxRect *arg1 = (wxRect *) 0 ;
5008 int arg2 ;
5009 PyObject * obj0 = 0 ;
5010 PyObject * obj1 = 0 ;
5011 char *kwnames[] = {
5012 (char *) "self",(char *) "y", NULL
5013 };
5014
5015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5017 if (SWIG_arg_fail(1)) SWIG_fail;
5018 {
5019 arg2 = (int)(SWIG_As_int(obj1));
5020 if (SWIG_arg_fail(2)) SWIG_fail;
5021 }
5022 {
5023 PyThreadState* __tstate = wxPyBeginAllowThreads();
5024 (arg1)->SetY(arg2);
5025
5026 wxPyEndAllowThreads(__tstate);
5027 if (PyErr_Occurred()) SWIG_fail;
5028 }
5029 Py_INCREF(Py_None); resultobj = Py_None;
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5037 PyObject *resultobj;
5038 wxRect *arg1 = (wxRect *) 0 ;
5039 int result;
5040 PyObject * obj0 = 0 ;
5041 char *kwnames[] = {
5042 (char *) "self", NULL
5043 };
5044
5045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5047 if (SWIG_arg_fail(1)) SWIG_fail;
5048 {
5049 PyThreadState* __tstate = wxPyBeginAllowThreads();
5050 result = (int)((wxRect const *)arg1)->GetWidth();
5051
5052 wxPyEndAllowThreads(__tstate);
5053 if (PyErr_Occurred()) SWIG_fail;
5054 }
5055 {
5056 resultobj = SWIG_From_int((int)(result));
5057 }
5058 return resultobj;
5059 fail:
5060 return NULL;
5061 }
5062
5063
5064 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5065 PyObject *resultobj;
5066 wxRect *arg1 = (wxRect *) 0 ;
5067 int arg2 ;
5068 PyObject * obj0 = 0 ;
5069 PyObject * obj1 = 0 ;
5070 char *kwnames[] = {
5071 (char *) "self",(char *) "w", NULL
5072 };
5073
5074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5076 if (SWIG_arg_fail(1)) SWIG_fail;
5077 {
5078 arg2 = (int)(SWIG_As_int(obj1));
5079 if (SWIG_arg_fail(2)) SWIG_fail;
5080 }
5081 {
5082 PyThreadState* __tstate = wxPyBeginAllowThreads();
5083 (arg1)->SetWidth(arg2);
5084
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 Py_INCREF(Py_None); resultobj = Py_None;
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5096 PyObject *resultobj;
5097 wxRect *arg1 = (wxRect *) 0 ;
5098 int result;
5099 PyObject * obj0 = 0 ;
5100 char *kwnames[] = {
5101 (char *) "self", NULL
5102 };
5103
5104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5106 if (SWIG_arg_fail(1)) SWIG_fail;
5107 {
5108 PyThreadState* __tstate = wxPyBeginAllowThreads();
5109 result = (int)((wxRect const *)arg1)->GetHeight();
5110
5111 wxPyEndAllowThreads(__tstate);
5112 if (PyErr_Occurred()) SWIG_fail;
5113 }
5114 {
5115 resultobj = SWIG_From_int((int)(result));
5116 }
5117 return resultobj;
5118 fail:
5119 return NULL;
5120 }
5121
5122
5123 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5124 PyObject *resultobj;
5125 wxRect *arg1 = (wxRect *) 0 ;
5126 int arg2 ;
5127 PyObject * obj0 = 0 ;
5128 PyObject * obj1 = 0 ;
5129 char *kwnames[] = {
5130 (char *) "self",(char *) "h", NULL
5131 };
5132
5133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5135 if (SWIG_arg_fail(1)) SWIG_fail;
5136 {
5137 arg2 = (int)(SWIG_As_int(obj1));
5138 if (SWIG_arg_fail(2)) SWIG_fail;
5139 }
5140 {
5141 PyThreadState* __tstate = wxPyBeginAllowThreads();
5142 (arg1)->SetHeight(arg2);
5143
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 Py_INCREF(Py_None); resultobj = Py_None;
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5155 PyObject *resultobj;
5156 wxRect *arg1 = (wxRect *) 0 ;
5157 wxPoint result;
5158 PyObject * obj0 = 0 ;
5159 char *kwnames[] = {
5160 (char *) "self", NULL
5161 };
5162
5163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5165 if (SWIG_arg_fail(1)) SWIG_fail;
5166 {
5167 PyThreadState* __tstate = wxPyBeginAllowThreads();
5168 result = ((wxRect const *)arg1)->GetPosition();
5169
5170 wxPyEndAllowThreads(__tstate);
5171 if (PyErr_Occurred()) SWIG_fail;
5172 }
5173 {
5174 wxPoint * resultptr;
5175 resultptr = new wxPoint((wxPoint &)(result));
5176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5177 }
5178 return resultobj;
5179 fail:
5180 return NULL;
5181 }
5182
5183
5184 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj;
5186 wxRect *arg1 = (wxRect *) 0 ;
5187 wxPoint *arg2 = 0 ;
5188 wxPoint temp2 ;
5189 PyObject * obj0 = 0 ;
5190 PyObject * obj1 = 0 ;
5191 char *kwnames[] = {
5192 (char *) "self",(char *) "p", NULL
5193 };
5194
5195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5197 if (SWIG_arg_fail(1)) SWIG_fail;
5198 {
5199 arg2 = &temp2;
5200 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5201 }
5202 {
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 (arg1)->SetPosition((wxPoint const &)*arg2);
5205
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 Py_INCREF(Py_None); resultobj = Py_None;
5210 return resultobj;
5211 fail:
5212 return NULL;
5213 }
5214
5215
5216 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5217 PyObject *resultobj;
5218 wxRect *arg1 = (wxRect *) 0 ;
5219 wxSize result;
5220 PyObject * obj0 = 0 ;
5221 char *kwnames[] = {
5222 (char *) "self", NULL
5223 };
5224
5225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5227 if (SWIG_arg_fail(1)) SWIG_fail;
5228 {
5229 PyThreadState* __tstate = wxPyBeginAllowThreads();
5230 result = ((wxRect const *)arg1)->GetSize();
5231
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 {
5236 wxSize * resultptr;
5237 resultptr = new wxSize((wxSize &)(result));
5238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5239 }
5240 return resultobj;
5241 fail:
5242 return NULL;
5243 }
5244
5245
5246 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5247 PyObject *resultobj;
5248 wxRect *arg1 = (wxRect *) 0 ;
5249 wxSize *arg2 = 0 ;
5250 wxSize temp2 ;
5251 PyObject * obj0 = 0 ;
5252 PyObject * obj1 = 0 ;
5253 char *kwnames[] = {
5254 (char *) "self",(char *) "s", NULL
5255 };
5256
5257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5259 if (SWIG_arg_fail(1)) SWIG_fail;
5260 {
5261 arg2 = &temp2;
5262 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5263 }
5264 {
5265 PyThreadState* __tstate = wxPyBeginAllowThreads();
5266 (arg1)->SetSize((wxSize const &)*arg2);
5267
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 Py_INCREF(Py_None); resultobj = Py_None;
5272 return resultobj;
5273 fail:
5274 return NULL;
5275 }
5276
5277
5278 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5279 PyObject *resultobj;
5280 wxRect *arg1 = (wxRect *) 0 ;
5281 wxPoint result;
5282 PyObject * obj0 = 0 ;
5283 char *kwnames[] = {
5284 (char *) "self", NULL
5285 };
5286
5287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5289 if (SWIG_arg_fail(1)) SWIG_fail;
5290 {
5291 PyThreadState* __tstate = wxPyBeginAllowThreads();
5292 result = ((wxRect const *)arg1)->GetTopLeft();
5293
5294 wxPyEndAllowThreads(__tstate);
5295 if (PyErr_Occurred()) SWIG_fail;
5296 }
5297 {
5298 wxPoint * resultptr;
5299 resultptr = new wxPoint((wxPoint &)(result));
5300 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5301 }
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5309 PyObject *resultobj;
5310 wxRect *arg1 = (wxRect *) 0 ;
5311 wxPoint *arg2 = 0 ;
5312 wxPoint temp2 ;
5313 PyObject * obj0 = 0 ;
5314 PyObject * obj1 = 0 ;
5315 char *kwnames[] = {
5316 (char *) "self",(char *) "p", NULL
5317 };
5318
5319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5321 if (SWIG_arg_fail(1)) SWIG_fail;
5322 {
5323 arg2 = &temp2;
5324 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5325 }
5326 {
5327 PyThreadState* __tstate = wxPyBeginAllowThreads();
5328 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5329
5330 wxPyEndAllowThreads(__tstate);
5331 if (PyErr_Occurred()) SWIG_fail;
5332 }
5333 Py_INCREF(Py_None); resultobj = Py_None;
5334 return resultobj;
5335 fail:
5336 return NULL;
5337 }
5338
5339
5340 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5341 PyObject *resultobj;
5342 wxRect *arg1 = (wxRect *) 0 ;
5343 wxPoint result;
5344 PyObject * obj0 = 0 ;
5345 char *kwnames[] = {
5346 (char *) "self", NULL
5347 };
5348
5349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5351 if (SWIG_arg_fail(1)) SWIG_fail;
5352 {
5353 PyThreadState* __tstate = wxPyBeginAllowThreads();
5354 result = ((wxRect const *)arg1)->GetBottomRight();
5355
5356 wxPyEndAllowThreads(__tstate);
5357 if (PyErr_Occurred()) SWIG_fail;
5358 }
5359 {
5360 wxPoint * resultptr;
5361 resultptr = new wxPoint((wxPoint &)(result));
5362 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5363 }
5364 return resultobj;
5365 fail:
5366 return NULL;
5367 }
5368
5369
5370 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5371 PyObject *resultobj;
5372 wxRect *arg1 = (wxRect *) 0 ;
5373 wxPoint *arg2 = 0 ;
5374 wxPoint temp2 ;
5375 PyObject * obj0 = 0 ;
5376 PyObject * obj1 = 0 ;
5377 char *kwnames[] = {
5378 (char *) "self",(char *) "p", NULL
5379 };
5380
5381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5383 if (SWIG_arg_fail(1)) SWIG_fail;
5384 {
5385 arg2 = &temp2;
5386 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5387 }
5388 {
5389 PyThreadState* __tstate = wxPyBeginAllowThreads();
5390 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5391
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 Py_INCREF(Py_None); resultobj = Py_None;
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj;
5404 wxRect *arg1 = (wxRect *) 0 ;
5405 int result;
5406 PyObject * obj0 = 0 ;
5407 char *kwnames[] = {
5408 (char *) "self", NULL
5409 };
5410
5411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5413 if (SWIG_arg_fail(1)) SWIG_fail;
5414 {
5415 PyThreadState* __tstate = wxPyBeginAllowThreads();
5416 result = (int)((wxRect const *)arg1)->GetLeft();
5417
5418 wxPyEndAllowThreads(__tstate);
5419 if (PyErr_Occurred()) SWIG_fail;
5420 }
5421 {
5422 resultobj = SWIG_From_int((int)(result));
5423 }
5424 return resultobj;
5425 fail:
5426 return NULL;
5427 }
5428
5429
5430 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5431 PyObject *resultobj;
5432 wxRect *arg1 = (wxRect *) 0 ;
5433 int result;
5434 PyObject * obj0 = 0 ;
5435 char *kwnames[] = {
5436 (char *) "self", NULL
5437 };
5438
5439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5441 if (SWIG_arg_fail(1)) SWIG_fail;
5442 {
5443 PyThreadState* __tstate = wxPyBeginAllowThreads();
5444 result = (int)((wxRect const *)arg1)->GetTop();
5445
5446 wxPyEndAllowThreads(__tstate);
5447 if (PyErr_Occurred()) SWIG_fail;
5448 }
5449 {
5450 resultobj = SWIG_From_int((int)(result));
5451 }
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj;
5460 wxRect *arg1 = (wxRect *) 0 ;
5461 int result;
5462 PyObject * obj0 = 0 ;
5463 char *kwnames[] = {
5464 (char *) "self", NULL
5465 };
5466
5467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5469 if (SWIG_arg_fail(1)) SWIG_fail;
5470 {
5471 PyThreadState* __tstate = wxPyBeginAllowThreads();
5472 result = (int)((wxRect const *)arg1)->GetBottom();
5473
5474 wxPyEndAllowThreads(__tstate);
5475 if (PyErr_Occurred()) SWIG_fail;
5476 }
5477 {
5478 resultobj = SWIG_From_int((int)(result));
5479 }
5480 return resultobj;
5481 fail:
5482 return NULL;
5483 }
5484
5485
5486 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5487 PyObject *resultobj;
5488 wxRect *arg1 = (wxRect *) 0 ;
5489 int result;
5490 PyObject * obj0 = 0 ;
5491 char *kwnames[] = {
5492 (char *) "self", NULL
5493 };
5494
5495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5497 if (SWIG_arg_fail(1)) SWIG_fail;
5498 {
5499 PyThreadState* __tstate = wxPyBeginAllowThreads();
5500 result = (int)((wxRect const *)arg1)->GetRight();
5501
5502 wxPyEndAllowThreads(__tstate);
5503 if (PyErr_Occurred()) SWIG_fail;
5504 }
5505 {
5506 resultobj = SWIG_From_int((int)(result));
5507 }
5508 return resultobj;
5509 fail:
5510 return NULL;
5511 }
5512
5513
5514 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5515 PyObject *resultobj;
5516 wxRect *arg1 = (wxRect *) 0 ;
5517 int arg2 ;
5518 PyObject * obj0 = 0 ;
5519 PyObject * obj1 = 0 ;
5520 char *kwnames[] = {
5521 (char *) "self",(char *) "left", NULL
5522 };
5523
5524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5526 if (SWIG_arg_fail(1)) SWIG_fail;
5527 {
5528 arg2 = (int)(SWIG_As_int(obj1));
5529 if (SWIG_arg_fail(2)) SWIG_fail;
5530 }
5531 {
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 (arg1)->SetLeft(arg2);
5534
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 Py_INCREF(Py_None); resultobj = Py_None;
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
5545 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5546 PyObject *resultobj;
5547 wxRect *arg1 = (wxRect *) 0 ;
5548 int arg2 ;
5549 PyObject * obj0 = 0 ;
5550 PyObject * obj1 = 0 ;
5551 char *kwnames[] = {
5552 (char *) "self",(char *) "right", NULL
5553 };
5554
5555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5557 if (SWIG_arg_fail(1)) SWIG_fail;
5558 {
5559 arg2 = (int)(SWIG_As_int(obj1));
5560 if (SWIG_arg_fail(2)) SWIG_fail;
5561 }
5562 {
5563 PyThreadState* __tstate = wxPyBeginAllowThreads();
5564 (arg1)->SetRight(arg2);
5565
5566 wxPyEndAllowThreads(__tstate);
5567 if (PyErr_Occurred()) SWIG_fail;
5568 }
5569 Py_INCREF(Py_None); resultobj = Py_None;
5570 return resultobj;
5571 fail:
5572 return NULL;
5573 }
5574
5575
5576 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5577 PyObject *resultobj;
5578 wxRect *arg1 = (wxRect *) 0 ;
5579 int arg2 ;
5580 PyObject * obj0 = 0 ;
5581 PyObject * obj1 = 0 ;
5582 char *kwnames[] = {
5583 (char *) "self",(char *) "top", NULL
5584 };
5585
5586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5588 if (SWIG_arg_fail(1)) SWIG_fail;
5589 {
5590 arg2 = (int)(SWIG_As_int(obj1));
5591 if (SWIG_arg_fail(2)) SWIG_fail;
5592 }
5593 {
5594 PyThreadState* __tstate = wxPyBeginAllowThreads();
5595 (arg1)->SetTop(arg2);
5596
5597 wxPyEndAllowThreads(__tstate);
5598 if (PyErr_Occurred()) SWIG_fail;
5599 }
5600 Py_INCREF(Py_None); resultobj = Py_None;
5601 return resultobj;
5602 fail:
5603 return NULL;
5604 }
5605
5606
5607 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5608 PyObject *resultobj;
5609 wxRect *arg1 = (wxRect *) 0 ;
5610 int arg2 ;
5611 PyObject * obj0 = 0 ;
5612 PyObject * obj1 = 0 ;
5613 char *kwnames[] = {
5614 (char *) "self",(char *) "bottom", NULL
5615 };
5616
5617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5619 if (SWIG_arg_fail(1)) SWIG_fail;
5620 {
5621 arg2 = (int)(SWIG_As_int(obj1));
5622 if (SWIG_arg_fail(2)) SWIG_fail;
5623 }
5624 {
5625 PyThreadState* __tstate = wxPyBeginAllowThreads();
5626 (arg1)->SetBottom(arg2);
5627
5628 wxPyEndAllowThreads(__tstate);
5629 if (PyErr_Occurred()) SWIG_fail;
5630 }
5631 Py_INCREF(Py_None); resultobj = Py_None;
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj;
5640 wxRect *arg1 = (wxRect *) 0 ;
5641 int arg2 ;
5642 int arg3 ;
5643 wxRect *result;
5644 PyObject * obj0 = 0 ;
5645 PyObject * obj1 = 0 ;
5646 PyObject * obj2 = 0 ;
5647 char *kwnames[] = {
5648 (char *) "self",(char *) "dx",(char *) "dy", NULL
5649 };
5650
5651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5653 if (SWIG_arg_fail(1)) SWIG_fail;
5654 {
5655 arg2 = (int)(SWIG_As_int(obj1));
5656 if (SWIG_arg_fail(2)) SWIG_fail;
5657 }
5658 {
5659 arg3 = (int)(SWIG_As_int(obj2));
5660 if (SWIG_arg_fail(3)) SWIG_fail;
5661 }
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 {
5665 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5666 result = (wxRect *) &_result_ref;
5667 }
5668
5669 wxPyEndAllowThreads(__tstate);
5670 if (PyErr_Occurred()) SWIG_fail;
5671 }
5672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5673 return resultobj;
5674 fail:
5675 return NULL;
5676 }
5677
5678
5679 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5680 PyObject *resultobj;
5681 wxRect *arg1 = (wxRect *) 0 ;
5682 int arg2 ;
5683 int arg3 ;
5684 wxRect *result;
5685 PyObject * obj0 = 0 ;
5686 PyObject * obj1 = 0 ;
5687 PyObject * obj2 = 0 ;
5688 char *kwnames[] = {
5689 (char *) "self",(char *) "dx",(char *) "dy", NULL
5690 };
5691
5692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5694 if (SWIG_arg_fail(1)) SWIG_fail;
5695 {
5696 arg2 = (int)(SWIG_As_int(obj1));
5697 if (SWIG_arg_fail(2)) SWIG_fail;
5698 }
5699 {
5700 arg3 = (int)(SWIG_As_int(obj2));
5701 if (SWIG_arg_fail(3)) SWIG_fail;
5702 }
5703 {
5704 PyThreadState* __tstate = wxPyBeginAllowThreads();
5705 {
5706 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5707 result = (wxRect *) &_result_ref;
5708 }
5709
5710 wxPyEndAllowThreads(__tstate);
5711 if (PyErr_Occurred()) SWIG_fail;
5712 }
5713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5714 return resultobj;
5715 fail:
5716 return NULL;
5717 }
5718
5719
5720 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5721 PyObject *resultobj;
5722 wxRect *arg1 = (wxRect *) 0 ;
5723 int arg2 ;
5724 int arg3 ;
5725 PyObject * obj0 = 0 ;
5726 PyObject * obj1 = 0 ;
5727 PyObject * obj2 = 0 ;
5728 char *kwnames[] = {
5729 (char *) "self",(char *) "dx",(char *) "dy", NULL
5730 };
5731
5732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5734 if (SWIG_arg_fail(1)) SWIG_fail;
5735 {
5736 arg2 = (int)(SWIG_As_int(obj1));
5737 if (SWIG_arg_fail(2)) SWIG_fail;
5738 }
5739 {
5740 arg3 = (int)(SWIG_As_int(obj2));
5741 if (SWIG_arg_fail(3)) SWIG_fail;
5742 }
5743 {
5744 PyThreadState* __tstate = wxPyBeginAllowThreads();
5745 (arg1)->Offset(arg2,arg3);
5746
5747 wxPyEndAllowThreads(__tstate);
5748 if (PyErr_Occurred()) SWIG_fail;
5749 }
5750 Py_INCREF(Py_None); resultobj = Py_None;
5751 return resultobj;
5752 fail:
5753 return NULL;
5754 }
5755
5756
5757 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5758 PyObject *resultobj;
5759 wxRect *arg1 = (wxRect *) 0 ;
5760 wxPoint *arg2 = 0 ;
5761 wxPoint temp2 ;
5762 PyObject * obj0 = 0 ;
5763 PyObject * obj1 = 0 ;
5764 char *kwnames[] = {
5765 (char *) "self",(char *) "pt", NULL
5766 };
5767
5768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5770 if (SWIG_arg_fail(1)) SWIG_fail;
5771 {
5772 arg2 = &temp2;
5773 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5774 }
5775 {
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 (arg1)->Offset((wxPoint const &)*arg2);
5778
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 Py_INCREF(Py_None); resultobj = Py_None;
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5790 PyObject *resultobj;
5791 wxRect *arg1 = (wxRect *) 0 ;
5792 wxRect *arg2 = 0 ;
5793 wxRect result;
5794 wxRect temp2 ;
5795 PyObject * obj0 = 0 ;
5796 PyObject * obj1 = 0 ;
5797 char *kwnames[] = {
5798 (char *) "self",(char *) "rect", NULL
5799 };
5800
5801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5803 if (SWIG_arg_fail(1)) SWIG_fail;
5804 {
5805 arg2 = &temp2;
5806 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5807 }
5808 {
5809 PyThreadState* __tstate = wxPyBeginAllowThreads();
5810 result = (arg1)->Intersect((wxRect const &)*arg2);
5811
5812 wxPyEndAllowThreads(__tstate);
5813 if (PyErr_Occurred()) SWIG_fail;
5814 }
5815 {
5816 wxRect * resultptr;
5817 resultptr = new wxRect((wxRect &)(result));
5818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5819 }
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj;
5828 wxRect *arg1 = (wxRect *) 0 ;
5829 wxRect *arg2 = 0 ;
5830 wxRect result;
5831 wxRect temp2 ;
5832 PyObject * obj0 = 0 ;
5833 PyObject * obj1 = 0 ;
5834 char *kwnames[] = {
5835 (char *) "self",(char *) "rect", NULL
5836 };
5837
5838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5840 if (SWIG_arg_fail(1)) SWIG_fail;
5841 {
5842 arg2 = &temp2;
5843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5844 }
5845 {
5846 PyThreadState* __tstate = wxPyBeginAllowThreads();
5847 result = (arg1)->Union((wxRect const &)*arg2);
5848
5849 wxPyEndAllowThreads(__tstate);
5850 if (PyErr_Occurred()) SWIG_fail;
5851 }
5852 {
5853 wxRect * resultptr;
5854 resultptr = new wxRect((wxRect &)(result));
5855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5856 }
5857 return resultobj;
5858 fail:
5859 return NULL;
5860 }
5861
5862
5863 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5864 PyObject *resultobj;
5865 wxRect *arg1 = (wxRect *) 0 ;
5866 wxRect *arg2 = 0 ;
5867 wxRect result;
5868 wxRect temp2 ;
5869 PyObject * obj0 = 0 ;
5870 PyObject * obj1 = 0 ;
5871 char *kwnames[] = {
5872 (char *) "self",(char *) "rect", NULL
5873 };
5874
5875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5877 if (SWIG_arg_fail(1)) SWIG_fail;
5878 {
5879 arg2 = &temp2;
5880 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5881 }
5882 {
5883 PyThreadState* __tstate = wxPyBeginAllowThreads();
5884 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5885
5886 wxPyEndAllowThreads(__tstate);
5887 if (PyErr_Occurred()) SWIG_fail;
5888 }
5889 {
5890 wxRect * resultptr;
5891 resultptr = new wxRect((wxRect &)(result));
5892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5893 }
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxRect *arg1 = (wxRect *) 0 ;
5903 wxRect *arg2 = 0 ;
5904 wxRect *result;
5905 wxRect temp2 ;
5906 PyObject * obj0 = 0 ;
5907 PyObject * obj1 = 0 ;
5908 char *kwnames[] = {
5909 (char *) "self",(char *) "rect", NULL
5910 };
5911
5912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5914 if (SWIG_arg_fail(1)) SWIG_fail;
5915 {
5916 arg2 = &temp2;
5917 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5918 }
5919 {
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 {
5922 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5923 result = (wxRect *) &_result_ref;
5924 }
5925
5926 wxPyEndAllowThreads(__tstate);
5927 if (PyErr_Occurred()) SWIG_fail;
5928 }
5929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5930 return resultobj;
5931 fail:
5932 return NULL;
5933 }
5934
5935
5936 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5937 PyObject *resultobj;
5938 wxRect *arg1 = (wxRect *) 0 ;
5939 wxRect *arg2 = 0 ;
5940 bool result;
5941 wxRect temp2 ;
5942 PyObject * obj0 = 0 ;
5943 PyObject * obj1 = 0 ;
5944 char *kwnames[] = {
5945 (char *) "self",(char *) "rect", NULL
5946 };
5947
5948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5950 if (SWIG_arg_fail(1)) SWIG_fail;
5951 {
5952 arg2 = &temp2;
5953 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5954 }
5955 {
5956 PyThreadState* __tstate = wxPyBeginAllowThreads();
5957 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5958
5959 wxPyEndAllowThreads(__tstate);
5960 if (PyErr_Occurred()) SWIG_fail;
5961 }
5962 {
5963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5964 }
5965 return resultobj;
5966 fail:
5967 return NULL;
5968 }
5969
5970
5971 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5972 PyObject *resultobj;
5973 wxRect *arg1 = (wxRect *) 0 ;
5974 wxRect *arg2 = 0 ;
5975 bool result;
5976 wxRect temp2 ;
5977 PyObject * obj0 = 0 ;
5978 PyObject * obj1 = 0 ;
5979 char *kwnames[] = {
5980 (char *) "self",(char *) "rect", NULL
5981 };
5982
5983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5985 if (SWIG_arg_fail(1)) SWIG_fail;
5986 {
5987 arg2 = &temp2;
5988 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5989 }
5990 {
5991 PyThreadState* __tstate = wxPyBeginAllowThreads();
5992 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5993
5994 wxPyEndAllowThreads(__tstate);
5995 if (PyErr_Occurred()) SWIG_fail;
5996 }
5997 {
5998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5999 }
6000 return resultobj;
6001 fail:
6002 return NULL;
6003 }
6004
6005
6006 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj;
6008 wxRect *arg1 = (wxRect *) 0 ;
6009 int arg2 ;
6010 int arg3 ;
6011 bool result;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 PyObject * obj2 = 0 ;
6015 char *kwnames[] = {
6016 (char *) "self",(char *) "x",(char *) "y", NULL
6017 };
6018
6019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6021 if (SWIG_arg_fail(1)) SWIG_fail;
6022 {
6023 arg2 = (int)(SWIG_As_int(obj1));
6024 if (SWIG_arg_fail(2)) SWIG_fail;
6025 }
6026 {
6027 arg3 = (int)(SWIG_As_int(obj2));
6028 if (SWIG_arg_fail(3)) SWIG_fail;
6029 }
6030 {
6031 PyThreadState* __tstate = wxPyBeginAllowThreads();
6032 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6033
6034 wxPyEndAllowThreads(__tstate);
6035 if (PyErr_Occurred()) SWIG_fail;
6036 }
6037 {
6038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6039 }
6040 return resultobj;
6041 fail:
6042 return NULL;
6043 }
6044
6045
6046 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj;
6048 wxRect *arg1 = (wxRect *) 0 ;
6049 wxPoint *arg2 = 0 ;
6050 bool result;
6051 wxPoint temp2 ;
6052 PyObject * obj0 = 0 ;
6053 PyObject * obj1 = 0 ;
6054 char *kwnames[] = {
6055 (char *) "self",(char *) "pt", NULL
6056 };
6057
6058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6060 if (SWIG_arg_fail(1)) SWIG_fail;
6061 {
6062 arg2 = &temp2;
6063 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6064 }
6065 {
6066 PyThreadState* __tstate = wxPyBeginAllowThreads();
6067 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6068
6069 wxPyEndAllowThreads(__tstate);
6070 if (PyErr_Occurred()) SWIG_fail;
6071 }
6072 {
6073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6074 }
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj;
6083 wxRect *arg1 = (wxRect *) 0 ;
6084 wxRect *arg2 = 0 ;
6085 bool result;
6086 wxRect temp2 ;
6087 PyObject * obj0 = 0 ;
6088 PyObject * obj1 = 0 ;
6089 char *kwnames[] = {
6090 (char *) "self",(char *) "rect", NULL
6091 };
6092
6093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6095 if (SWIG_arg_fail(1)) SWIG_fail;
6096 {
6097 arg2 = &temp2;
6098 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6099 }
6100 {
6101 PyThreadState* __tstate = wxPyBeginAllowThreads();
6102 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6103
6104 wxPyEndAllowThreads(__tstate);
6105 if (PyErr_Occurred()) SWIG_fail;
6106 }
6107 {
6108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6109 }
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj;
6118 wxRect *arg1 = (wxRect *) 0 ;
6119 int arg2 ;
6120 PyObject * obj0 = 0 ;
6121 PyObject * obj1 = 0 ;
6122 char *kwnames[] = {
6123 (char *) "self",(char *) "x", NULL
6124 };
6125
6126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6128 if (SWIG_arg_fail(1)) SWIG_fail;
6129 {
6130 arg2 = (int)(SWIG_As_int(obj1));
6131 if (SWIG_arg_fail(2)) SWIG_fail;
6132 }
6133 if (arg1) (arg1)->x = arg2;
6134
6135 Py_INCREF(Py_None); resultobj = Py_None;
6136 return resultobj;
6137 fail:
6138 return NULL;
6139 }
6140
6141
6142 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6143 PyObject *resultobj;
6144 wxRect *arg1 = (wxRect *) 0 ;
6145 int result;
6146 PyObject * obj0 = 0 ;
6147 char *kwnames[] = {
6148 (char *) "self", NULL
6149 };
6150
6151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6153 if (SWIG_arg_fail(1)) SWIG_fail;
6154 result = (int) ((arg1)->x);
6155
6156 {
6157 resultobj = SWIG_From_int((int)(result));
6158 }
6159 return resultobj;
6160 fail:
6161 return NULL;
6162 }
6163
6164
6165 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6166 PyObject *resultobj;
6167 wxRect *arg1 = (wxRect *) 0 ;
6168 int arg2 ;
6169 PyObject * obj0 = 0 ;
6170 PyObject * obj1 = 0 ;
6171 char *kwnames[] = {
6172 (char *) "self",(char *) "y", NULL
6173 };
6174
6175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6177 if (SWIG_arg_fail(1)) SWIG_fail;
6178 {
6179 arg2 = (int)(SWIG_As_int(obj1));
6180 if (SWIG_arg_fail(2)) SWIG_fail;
6181 }
6182 if (arg1) (arg1)->y = arg2;
6183
6184 Py_INCREF(Py_None); resultobj = Py_None;
6185 return resultobj;
6186 fail:
6187 return NULL;
6188 }
6189
6190
6191 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6192 PyObject *resultobj;
6193 wxRect *arg1 = (wxRect *) 0 ;
6194 int result;
6195 PyObject * obj0 = 0 ;
6196 char *kwnames[] = {
6197 (char *) "self", NULL
6198 };
6199
6200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 result = (int) ((arg1)->y);
6204
6205 {
6206 resultobj = SWIG_From_int((int)(result));
6207 }
6208 return resultobj;
6209 fail:
6210 return NULL;
6211 }
6212
6213
6214 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6215 PyObject *resultobj;
6216 wxRect *arg1 = (wxRect *) 0 ;
6217 int arg2 ;
6218 PyObject * obj0 = 0 ;
6219 PyObject * obj1 = 0 ;
6220 char *kwnames[] = {
6221 (char *) "self",(char *) "width", NULL
6222 };
6223
6224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6226 if (SWIG_arg_fail(1)) SWIG_fail;
6227 {
6228 arg2 = (int)(SWIG_As_int(obj1));
6229 if (SWIG_arg_fail(2)) SWIG_fail;
6230 }
6231 if (arg1) (arg1)->width = arg2;
6232
6233 Py_INCREF(Py_None); resultobj = Py_None;
6234 return resultobj;
6235 fail:
6236 return NULL;
6237 }
6238
6239
6240 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6241 PyObject *resultobj;
6242 wxRect *arg1 = (wxRect *) 0 ;
6243 int result;
6244 PyObject * obj0 = 0 ;
6245 char *kwnames[] = {
6246 (char *) "self", NULL
6247 };
6248
6249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6251 if (SWIG_arg_fail(1)) SWIG_fail;
6252 result = (int) ((arg1)->width);
6253
6254 {
6255 resultobj = SWIG_From_int((int)(result));
6256 }
6257 return resultobj;
6258 fail:
6259 return NULL;
6260 }
6261
6262
6263 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6264 PyObject *resultobj;
6265 wxRect *arg1 = (wxRect *) 0 ;
6266 int arg2 ;
6267 PyObject * obj0 = 0 ;
6268 PyObject * obj1 = 0 ;
6269 char *kwnames[] = {
6270 (char *) "self",(char *) "height", NULL
6271 };
6272
6273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6275 if (SWIG_arg_fail(1)) SWIG_fail;
6276 {
6277 arg2 = (int)(SWIG_As_int(obj1));
6278 if (SWIG_arg_fail(2)) SWIG_fail;
6279 }
6280 if (arg1) (arg1)->height = arg2;
6281
6282 Py_INCREF(Py_None); resultobj = Py_None;
6283 return resultobj;
6284 fail:
6285 return NULL;
6286 }
6287
6288
6289 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6290 PyObject *resultobj;
6291 wxRect *arg1 = (wxRect *) 0 ;
6292 int result;
6293 PyObject * obj0 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "self", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6300 if (SWIG_arg_fail(1)) SWIG_fail;
6301 result = (int) ((arg1)->height);
6302
6303 {
6304 resultobj = SWIG_From_int((int)(result));
6305 }
6306 return resultobj;
6307 fail:
6308 return NULL;
6309 }
6310
6311
6312 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6313 PyObject *resultobj;
6314 wxRect *arg1 = (wxRect *) 0 ;
6315 int arg2 = (int) 0 ;
6316 int arg3 = (int) 0 ;
6317 int arg4 = (int) 0 ;
6318 int arg5 = (int) 0 ;
6319 PyObject * obj0 = 0 ;
6320 PyObject * obj1 = 0 ;
6321 PyObject * obj2 = 0 ;
6322 PyObject * obj3 = 0 ;
6323 PyObject * obj4 = 0 ;
6324 char *kwnames[] = {
6325 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6326 };
6327
6328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6330 if (SWIG_arg_fail(1)) SWIG_fail;
6331 if (obj1) {
6332 {
6333 arg2 = (int)(SWIG_As_int(obj1));
6334 if (SWIG_arg_fail(2)) SWIG_fail;
6335 }
6336 }
6337 if (obj2) {
6338 {
6339 arg3 = (int)(SWIG_As_int(obj2));
6340 if (SWIG_arg_fail(3)) SWIG_fail;
6341 }
6342 }
6343 if (obj3) {
6344 {
6345 arg4 = (int)(SWIG_As_int(obj3));
6346 if (SWIG_arg_fail(4)) SWIG_fail;
6347 }
6348 }
6349 if (obj4) {
6350 {
6351 arg5 = (int)(SWIG_As_int(obj4));
6352 if (SWIG_arg_fail(5)) SWIG_fail;
6353 }
6354 }
6355 {
6356 PyThreadState* __tstate = wxPyBeginAllowThreads();
6357 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6358
6359 wxPyEndAllowThreads(__tstate);
6360 if (PyErr_Occurred()) SWIG_fail;
6361 }
6362 Py_INCREF(Py_None); resultobj = Py_None;
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6370 PyObject *resultobj;
6371 wxRect *arg1 = (wxRect *) 0 ;
6372 PyObject *result;
6373 PyObject * obj0 = 0 ;
6374 char *kwnames[] = {
6375 (char *) "self", NULL
6376 };
6377
6378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6380 if (SWIG_arg_fail(1)) SWIG_fail;
6381 {
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 result = (PyObject *)wxRect_Get(arg1);
6384
6385 wxPyEndAllowThreads(__tstate);
6386 if (PyErr_Occurred()) SWIG_fail;
6387 }
6388 resultobj = result;
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6396 PyObject *obj;
6397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6398 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6399 Py_INCREF(obj);
6400 return Py_BuildValue((char *)"");
6401 }
6402 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj;
6404 wxRect *arg1 = (wxRect *) 0 ;
6405 wxRect *arg2 = (wxRect *) 0 ;
6406 PyObject *result;
6407 PyObject * obj0 = 0 ;
6408 PyObject * obj1 = 0 ;
6409 char *kwnames[] = {
6410 (char *) "r1",(char *) "r2", NULL
6411 };
6412
6413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6415 if (SWIG_arg_fail(1)) SWIG_fail;
6416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6417 if (SWIG_arg_fail(2)) SWIG_fail;
6418 {
6419 if (!wxPyCheckForApp()) SWIG_fail;
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 result = (PyObject *)wxIntersectRect(arg1,arg2);
6422
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 resultobj = result;
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj;
6435 double arg1 = (double) 0.0 ;
6436 double arg2 = (double) 0.0 ;
6437 wxPoint2D *result;
6438 PyObject * obj0 = 0 ;
6439 PyObject * obj1 = 0 ;
6440 char *kwnames[] = {
6441 (char *) "x",(char *) "y", NULL
6442 };
6443
6444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6445 if (obj0) {
6446 {
6447 arg1 = (double)(SWIG_As_double(obj0));
6448 if (SWIG_arg_fail(1)) SWIG_fail;
6449 }
6450 }
6451 if (obj1) {
6452 {
6453 arg2 = (double)(SWIG_As_double(obj1));
6454 if (SWIG_arg_fail(2)) SWIG_fail;
6455 }
6456 }
6457 {
6458 PyThreadState* __tstate = wxPyBeginAllowThreads();
6459 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6460
6461 wxPyEndAllowThreads(__tstate);
6462 if (PyErr_Occurred()) SWIG_fail;
6463 }
6464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6472 PyObject *resultobj;
6473 wxPoint2D *arg1 = 0 ;
6474 wxPoint2D *result;
6475 wxPoint2D temp1 ;
6476 PyObject * obj0 = 0 ;
6477 char *kwnames[] = {
6478 (char *) "pt", NULL
6479 };
6480
6481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6482 {
6483 arg1 = &temp1;
6484 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6485 }
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6489
6490 wxPyEndAllowThreads(__tstate);
6491 if (PyErr_Occurred()) SWIG_fail;
6492 }
6493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6494 return resultobj;
6495 fail:
6496 return NULL;
6497 }
6498
6499
6500 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6501 PyObject *resultobj;
6502 wxPoint *arg1 = 0 ;
6503 wxPoint2D *result;
6504 wxPoint temp1 ;
6505 PyObject * obj0 = 0 ;
6506 char *kwnames[] = {
6507 (char *) "pt", NULL
6508 };
6509
6510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6511 {
6512 arg1 = &temp1;
6513 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6514 }
6515 {
6516 PyThreadState* __tstate = wxPyBeginAllowThreads();
6517 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6518
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6523 return resultobj;
6524 fail:
6525 return NULL;
6526 }
6527
6528
6529 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6530 PyObject *resultobj;
6531 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6532 int *arg2 = (int *) 0 ;
6533 int *arg3 = (int *) 0 ;
6534 int temp2 ;
6535 int res2 = 0 ;
6536 int temp3 ;
6537 int res3 = 0 ;
6538 PyObject * obj0 = 0 ;
6539 char *kwnames[] = {
6540 (char *) "self", NULL
6541 };
6542
6543 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6544 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6547 if (SWIG_arg_fail(1)) SWIG_fail;
6548 {
6549 PyThreadState* __tstate = wxPyBeginAllowThreads();
6550 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6551
6552 wxPyEndAllowThreads(__tstate);
6553 if (PyErr_Occurred()) SWIG_fail;
6554 }
6555 Py_INCREF(Py_None); resultobj = Py_None;
6556 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6557 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6558 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6559 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6560 return resultobj;
6561 fail:
6562 return NULL;
6563 }
6564
6565
6566 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6567 PyObject *resultobj;
6568 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6569 int *arg2 = (int *) 0 ;
6570 int *arg3 = (int *) 0 ;
6571 int temp2 ;
6572 int res2 = 0 ;
6573 int temp3 ;
6574 int res3 = 0 ;
6575 PyObject * obj0 = 0 ;
6576 char *kwnames[] = {
6577 (char *) "self", NULL
6578 };
6579
6580 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6581 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6584 if (SWIG_arg_fail(1)) SWIG_fail;
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6588
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 Py_INCREF(Py_None); resultobj = Py_None;
6593 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6594 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6595 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6596 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6597 return resultobj;
6598 fail:
6599 return NULL;
6600 }
6601
6602
6603 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6604 PyObject *resultobj;
6605 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6606 double result;
6607 PyObject * obj0 = 0 ;
6608 char *kwnames[] = {
6609 (char *) "self", NULL
6610 };
6611
6612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6614 if (SWIG_arg_fail(1)) SWIG_fail;
6615 {
6616 PyThreadState* __tstate = wxPyBeginAllowThreads();
6617 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6618
6619 wxPyEndAllowThreads(__tstate);
6620 if (PyErr_Occurred()) SWIG_fail;
6621 }
6622 {
6623 resultobj = SWIG_From_double((double)(result));
6624 }
6625 return resultobj;
6626 fail:
6627 return NULL;
6628 }
6629
6630
6631 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6632 PyObject *resultobj;
6633 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6634 double result;
6635 PyObject * obj0 = 0 ;
6636 char *kwnames[] = {
6637 (char *) "self", NULL
6638 };
6639
6640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6642 if (SWIG_arg_fail(1)) SWIG_fail;
6643 {
6644 PyThreadState* __tstate = wxPyBeginAllowThreads();
6645 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6646
6647 wxPyEndAllowThreads(__tstate);
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 {
6651 resultobj = SWIG_From_double((double)(result));
6652 }
6653 return resultobj;
6654 fail:
6655 return NULL;
6656 }
6657
6658
6659 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6660 PyObject *resultobj;
6661 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6662 double arg2 ;
6663 PyObject * obj0 = 0 ;
6664 PyObject * obj1 = 0 ;
6665 char *kwnames[] = {
6666 (char *) "self",(char *) "length", NULL
6667 };
6668
6669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6671 if (SWIG_arg_fail(1)) SWIG_fail;
6672 {
6673 arg2 = (double)(SWIG_As_double(obj1));
6674 if (SWIG_arg_fail(2)) SWIG_fail;
6675 }
6676 {
6677 PyThreadState* __tstate = wxPyBeginAllowThreads();
6678 (arg1)->SetVectorLength(arg2);
6679
6680 wxPyEndAllowThreads(__tstate);
6681 if (PyErr_Occurred()) SWIG_fail;
6682 }
6683 Py_INCREF(Py_None); resultobj = Py_None;
6684 return resultobj;
6685 fail:
6686 return NULL;
6687 }
6688
6689
6690 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6691 PyObject *resultobj;
6692 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6693 double arg2 ;
6694 PyObject * obj0 = 0 ;
6695 PyObject * obj1 = 0 ;
6696 char *kwnames[] = {
6697 (char *) "self",(char *) "degrees", NULL
6698 };
6699
6700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6702 if (SWIG_arg_fail(1)) SWIG_fail;
6703 {
6704 arg2 = (double)(SWIG_As_double(obj1));
6705 if (SWIG_arg_fail(2)) SWIG_fail;
6706 }
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 (arg1)->SetVectorAngle(arg2);
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 Py_INCREF(Py_None); resultobj = Py_None;
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj;
6723 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6724 wxPoint2D *arg2 = 0 ;
6725 double result;
6726 wxPoint2D temp2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char *kwnames[] = {
6730 (char *) "self",(char *) "pt", NULL
6731 };
6732
6733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6735 if (SWIG_arg_fail(1)) SWIG_fail;
6736 {
6737 arg2 = &temp2;
6738 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6739 }
6740 {
6741 PyThreadState* __tstate = wxPyBeginAllowThreads();
6742 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6743
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 {
6748 resultobj = SWIG_From_double((double)(result));
6749 }
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6757 PyObject *resultobj;
6758 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6759 wxPoint2D *arg2 = 0 ;
6760 double result;
6761 wxPoint2D temp2 ;
6762 PyObject * obj0 = 0 ;
6763 PyObject * obj1 = 0 ;
6764 char *kwnames[] = {
6765 (char *) "self",(char *) "pt", NULL
6766 };
6767
6768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6770 if (SWIG_arg_fail(1)) SWIG_fail;
6771 {
6772 arg2 = &temp2;
6773 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6774 }
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6778
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 {
6783 resultobj = SWIG_From_double((double)(result));
6784 }
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj;
6793 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6794 wxPoint2D *arg2 = 0 ;
6795 double result;
6796 wxPoint2D temp2 ;
6797 PyObject * obj0 = 0 ;
6798 PyObject * obj1 = 0 ;
6799 char *kwnames[] = {
6800 (char *) "self",(char *) "vec", NULL
6801 };
6802
6803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6805 if (SWIG_arg_fail(1)) SWIG_fail;
6806 {
6807 arg2 = &temp2;
6808 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6809 }
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6813
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 {
6818 resultobj = SWIG_From_double((double)(result));
6819 }
6820 return resultobj;
6821 fail:
6822 return NULL;
6823 }
6824
6825
6826 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6827 PyObject *resultobj;
6828 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6829 wxPoint2D *arg2 = 0 ;
6830 double result;
6831 wxPoint2D temp2 ;
6832 PyObject * obj0 = 0 ;
6833 PyObject * obj1 = 0 ;
6834 char *kwnames[] = {
6835 (char *) "self",(char *) "vec", NULL
6836 };
6837
6838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6840 if (SWIG_arg_fail(1)) SWIG_fail;
6841 {
6842 arg2 = &temp2;
6843 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6844 }
6845 {
6846 PyThreadState* __tstate = wxPyBeginAllowThreads();
6847 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6848
6849 wxPyEndAllowThreads(__tstate);
6850 if (PyErr_Occurred()) SWIG_fail;
6851 }
6852 {
6853 resultobj = SWIG_From_double((double)(result));
6854 }
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6862 PyObject *resultobj;
6863 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6864 wxPoint2D result;
6865 PyObject * obj0 = 0 ;
6866 char *kwnames[] = {
6867 (char *) "self", NULL
6868 };
6869
6870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6872 if (SWIG_arg_fail(1)) SWIG_fail;
6873 {
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 result = (arg1)->operator -();
6876
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 {
6881 wxPoint2D * resultptr;
6882 resultptr = new wxPoint2D((wxPoint2D &)(result));
6883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6884 }
6885 return resultobj;
6886 fail:
6887 return NULL;
6888 }
6889
6890
6891 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6892 PyObject *resultobj;
6893 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6894 wxPoint2D *arg2 = 0 ;
6895 wxPoint2D *result;
6896 wxPoint2D temp2 ;
6897 PyObject * obj0 = 0 ;
6898 PyObject * obj1 = 0 ;
6899 char *kwnames[] = {
6900 (char *) "self",(char *) "pt", NULL
6901 };
6902
6903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6905 if (SWIG_arg_fail(1)) SWIG_fail;
6906 {
6907 arg2 = &temp2;
6908 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6909 }
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 {
6913 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6914 result = (wxPoint2D *) &_result_ref;
6915 }
6916
6917 wxPyEndAllowThreads(__tstate);
6918 if (PyErr_Occurred()) SWIG_fail;
6919 }
6920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6921 return resultobj;
6922 fail:
6923 return NULL;
6924 }
6925
6926
6927 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6928 PyObject *resultobj;
6929 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6930 wxPoint2D *arg2 = 0 ;
6931 wxPoint2D *result;
6932 wxPoint2D temp2 ;
6933 PyObject * obj0 = 0 ;
6934 PyObject * obj1 = 0 ;
6935 char *kwnames[] = {
6936 (char *) "self",(char *) "pt", NULL
6937 };
6938
6939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6941 if (SWIG_arg_fail(1)) SWIG_fail;
6942 {
6943 arg2 = &temp2;
6944 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6945 }
6946 {
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 {
6949 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6950 result = (wxPoint2D *) &_result_ref;
6951 }
6952
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj;
6965 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6966 wxPoint2D *arg2 = 0 ;
6967 wxPoint2D *result;
6968 wxPoint2D temp2 ;
6969 PyObject * obj0 = 0 ;
6970 PyObject * obj1 = 0 ;
6971 char *kwnames[] = {
6972 (char *) "self",(char *) "pt", NULL
6973 };
6974
6975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6977 if (SWIG_arg_fail(1)) SWIG_fail;
6978 {
6979 arg2 = &temp2;
6980 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6981 }
6982 {
6983 PyThreadState* __tstate = wxPyBeginAllowThreads();
6984 {
6985 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6986 result = (wxPoint2D *) &_result_ref;
6987 }
6988
6989 wxPyEndAllowThreads(__tstate);
6990 if (PyErr_Occurred()) SWIG_fail;
6991 }
6992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6993 return resultobj;
6994 fail:
6995 return NULL;
6996 }
6997
6998
6999 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7000 PyObject *resultobj;
7001 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7002 wxPoint2D *arg2 = 0 ;
7003 wxPoint2D *result;
7004 wxPoint2D temp2 ;
7005 PyObject * obj0 = 0 ;
7006 PyObject * obj1 = 0 ;
7007 char *kwnames[] = {
7008 (char *) "self",(char *) "pt", NULL
7009 };
7010
7011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7013 if (SWIG_arg_fail(1)) SWIG_fail;
7014 {
7015 arg2 = &temp2;
7016 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7017 }
7018 {
7019 PyThreadState* __tstate = wxPyBeginAllowThreads();
7020 {
7021 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7022 result = (wxPoint2D *) &_result_ref;
7023 }
7024
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj;
7037 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7038 wxPoint2D *arg2 = 0 ;
7039 bool result;
7040 wxPoint2D temp2 ;
7041 PyObject * obj0 = 0 ;
7042 PyObject * obj1 = 0 ;
7043 char *kwnames[] = {
7044 (char *) "self",(char *) "pt", NULL
7045 };
7046
7047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7049 if (SWIG_arg_fail(1)) SWIG_fail;
7050 {
7051 arg2 = &temp2;
7052 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7053 }
7054 {
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7057
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 {
7062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7063 }
7064 return resultobj;
7065 fail:
7066 return NULL;
7067 }
7068
7069
7070 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7071 PyObject *resultobj;
7072 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7073 wxPoint2D *arg2 = 0 ;
7074 bool result;
7075 wxPoint2D temp2 ;
7076 PyObject * obj0 = 0 ;
7077 PyObject * obj1 = 0 ;
7078 char *kwnames[] = {
7079 (char *) "self",(char *) "pt", NULL
7080 };
7081
7082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7084 if (SWIG_arg_fail(1)) SWIG_fail;
7085 {
7086 arg2 = &temp2;
7087 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7088 }
7089 {
7090 PyThreadState* __tstate = wxPyBeginAllowThreads();
7091 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7092
7093 wxPyEndAllowThreads(__tstate);
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 {
7097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7098 }
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7106 PyObject *resultobj;
7107 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7108 double arg2 ;
7109 PyObject * obj0 = 0 ;
7110 PyObject * obj1 = 0 ;
7111 char *kwnames[] = {
7112 (char *) "self",(char *) "m_x", NULL
7113 };
7114
7115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7117 if (SWIG_arg_fail(1)) SWIG_fail;
7118 {
7119 arg2 = (double)(SWIG_As_double(obj1));
7120 if (SWIG_arg_fail(2)) SWIG_fail;
7121 }
7122 if (arg1) (arg1)->m_x = arg2;
7123
7124 Py_INCREF(Py_None); resultobj = Py_None;
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7132 PyObject *resultobj;
7133 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7134 double result;
7135 PyObject * obj0 = 0 ;
7136 char *kwnames[] = {
7137 (char *) "self", NULL
7138 };
7139
7140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7142 if (SWIG_arg_fail(1)) SWIG_fail;
7143 result = (double) ((arg1)->m_x);
7144
7145 {
7146 resultobj = SWIG_From_double((double)(result));
7147 }
7148 return resultobj;
7149 fail:
7150 return NULL;
7151 }
7152
7153
7154 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7155 PyObject *resultobj;
7156 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7157 double arg2 ;
7158 PyObject * obj0 = 0 ;
7159 PyObject * obj1 = 0 ;
7160 char *kwnames[] = {
7161 (char *) "self",(char *) "m_y", NULL
7162 };
7163
7164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7166 if (SWIG_arg_fail(1)) SWIG_fail;
7167 {
7168 arg2 = (double)(SWIG_As_double(obj1));
7169 if (SWIG_arg_fail(2)) SWIG_fail;
7170 }
7171 if (arg1) (arg1)->m_y = arg2;
7172
7173 Py_INCREF(Py_None); resultobj = Py_None;
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj;
7182 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7183 double result;
7184 PyObject * obj0 = 0 ;
7185 char *kwnames[] = {
7186 (char *) "self", NULL
7187 };
7188
7189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7191 if (SWIG_arg_fail(1)) SWIG_fail;
7192 result = (double) ((arg1)->m_y);
7193
7194 {
7195 resultobj = SWIG_From_double((double)(result));
7196 }
7197 return resultobj;
7198 fail:
7199 return NULL;
7200 }
7201
7202
7203 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7204 PyObject *resultobj;
7205 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7206 double arg2 = (double) 0 ;
7207 double arg3 = (double) 0 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 PyObject * obj2 = 0 ;
7211 char *kwnames[] = {
7212 (char *) "self",(char *) "x",(char *) "y", NULL
7213 };
7214
7215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7217 if (SWIG_arg_fail(1)) SWIG_fail;
7218 if (obj1) {
7219 {
7220 arg2 = (double)(SWIG_As_double(obj1));
7221 if (SWIG_arg_fail(2)) SWIG_fail;
7222 }
7223 }
7224 if (obj2) {
7225 {
7226 arg3 = (double)(SWIG_As_double(obj2));
7227 if (SWIG_arg_fail(3)) SWIG_fail;
7228 }
7229 }
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 wxPoint2D_Set(arg1,arg2,arg3);
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 Py_INCREF(Py_None); resultobj = Py_None;
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7247 PyObject *result;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 result = (PyObject *)wxPoint2D_Get(arg1);
7259
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 resultobj = result;
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7271 PyObject *obj;
7272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7273 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7274 Py_INCREF(obj);
7275 return Py_BuildValue((char *)"");
7276 }
7277 static int _wrap_DefaultPosition_set(PyObject *) {
7278 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7279 return 1;
7280 }
7281
7282
7283 static PyObject *_wrap_DefaultPosition_get(void) {
7284 PyObject *pyobj;
7285
7286 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7287 return pyobj;
7288 }
7289
7290
7291 static int _wrap_DefaultSize_set(PyObject *) {
7292 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7293 return 1;
7294 }
7295
7296
7297 static PyObject *_wrap_DefaultSize_get(void) {
7298 PyObject *pyobj;
7299
7300 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7301 return pyobj;
7302 }
7303
7304
7305 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7306 PyObject *resultobj;
7307 PyObject *arg1 = (PyObject *) 0 ;
7308 wxPyInputStream *result;
7309 PyObject * obj0 = 0 ;
7310 char *kwnames[] = {
7311 (char *) "p", NULL
7312 };
7313
7314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7315 arg1 = obj0;
7316 {
7317 PyThreadState* __tstate = wxPyBeginAllowThreads();
7318 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7319
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7331 PyObject *resultobj;
7332 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7333 PyObject * obj0 = 0 ;
7334 char *kwnames[] = {
7335 (char *) "self", NULL
7336 };
7337
7338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7340 if (SWIG_arg_fail(1)) SWIG_fail;
7341 {
7342 PyThreadState* __tstate = wxPyBeginAllowThreads();
7343 delete arg1;
7344
7345 wxPyEndAllowThreads(__tstate);
7346 if (PyErr_Occurred()) SWIG_fail;
7347 }
7348 Py_INCREF(Py_None); resultobj = Py_None;
7349 return resultobj;
7350 fail:
7351 return NULL;
7352 }
7353
7354
7355 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7356 PyObject *resultobj;
7357 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7358 PyObject * obj0 = 0 ;
7359 char *kwnames[] = {
7360 (char *) "self", NULL
7361 };
7362
7363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7365 if (SWIG_arg_fail(1)) SWIG_fail;
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 (arg1)->close();
7369
7370 wxPyEndAllowThreads(__tstate);
7371 if (PyErr_Occurred()) SWIG_fail;
7372 }
7373 Py_INCREF(Py_None); resultobj = Py_None;
7374 return resultobj;
7375 fail:
7376 return NULL;
7377 }
7378
7379
7380 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7381 PyObject *resultobj;
7382 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7383 PyObject * obj0 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "self", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7390 if (SWIG_arg_fail(1)) SWIG_fail;
7391 {
7392 PyThreadState* __tstate = wxPyBeginAllowThreads();
7393 (arg1)->flush();
7394
7395 wxPyEndAllowThreads(__tstate);
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 Py_INCREF(Py_None); resultobj = Py_None;
7399 return resultobj;
7400 fail:
7401 return NULL;
7402 }
7403
7404
7405 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7406 PyObject *resultobj;
7407 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7408 bool result;
7409 PyObject * obj0 = 0 ;
7410 char *kwnames[] = {
7411 (char *) "self", NULL
7412 };
7413
7414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7416 if (SWIG_arg_fail(1)) SWIG_fail;
7417 {
7418 PyThreadState* __tstate = wxPyBeginAllowThreads();
7419 result = (bool)(arg1)->eof();
7420
7421 wxPyEndAllowThreads(__tstate);
7422 if (PyErr_Occurred()) SWIG_fail;
7423 }
7424 {
7425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7426 }
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj;
7435 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7436 int arg2 = (int) -1 ;
7437 PyObject *result;
7438 PyObject * obj0 = 0 ;
7439 PyObject * obj1 = 0 ;
7440 char *kwnames[] = {
7441 (char *) "self",(char *) "size", NULL
7442 };
7443
7444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7446 if (SWIG_arg_fail(1)) SWIG_fail;
7447 if (obj1) {
7448 {
7449 arg2 = (int)(SWIG_As_int(obj1));
7450 if (SWIG_arg_fail(2)) SWIG_fail;
7451 }
7452 }
7453 {
7454 PyThreadState* __tstate = wxPyBeginAllowThreads();
7455 result = (PyObject *)(arg1)->read(arg2);
7456
7457 wxPyEndAllowThreads(__tstate);
7458 if (PyErr_Occurred()) SWIG_fail;
7459 }
7460 resultobj = result;
7461 return resultobj;
7462 fail:
7463 return NULL;
7464 }
7465
7466
7467 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7468 PyObject *resultobj;
7469 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7470 int arg2 = (int) -1 ;
7471 PyObject *result;
7472 PyObject * obj0 = 0 ;
7473 PyObject * obj1 = 0 ;
7474 char *kwnames[] = {
7475 (char *) "self",(char *) "size", NULL
7476 };
7477
7478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7480 if (SWIG_arg_fail(1)) SWIG_fail;
7481 if (obj1) {
7482 {
7483 arg2 = (int)(SWIG_As_int(obj1));
7484 if (SWIG_arg_fail(2)) SWIG_fail;
7485 }
7486 }
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (PyObject *)(arg1)->readline(arg2);
7490
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 resultobj = result;
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj;
7503 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7504 int arg2 = (int) -1 ;
7505 PyObject *result;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 char *kwnames[] = {
7509 (char *) "self",(char *) "sizehint", NULL
7510 };
7511
7512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7514 if (SWIG_arg_fail(1)) SWIG_fail;
7515 if (obj1) {
7516 {
7517 arg2 = (int)(SWIG_As_int(obj1));
7518 if (SWIG_arg_fail(2)) SWIG_fail;
7519 }
7520 }
7521 {
7522 PyThreadState* __tstate = wxPyBeginAllowThreads();
7523 result = (PyObject *)(arg1)->readlines(arg2);
7524
7525 wxPyEndAllowThreads(__tstate);
7526 if (PyErr_Occurred()) SWIG_fail;
7527 }
7528 resultobj = result;
7529 return resultobj;
7530 fail:
7531 return NULL;
7532 }
7533
7534
7535 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7536 PyObject *resultobj;
7537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7538 int arg2 ;
7539 int arg3 = (int) 0 ;
7540 PyObject * obj0 = 0 ;
7541 PyObject * obj1 = 0 ;
7542 PyObject * obj2 = 0 ;
7543 char *kwnames[] = {
7544 (char *) "self",(char *) "offset",(char *) "whence", NULL
7545 };
7546
7547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7549 if (SWIG_arg_fail(1)) SWIG_fail;
7550 {
7551 arg2 = (int)(SWIG_As_int(obj1));
7552 if (SWIG_arg_fail(2)) SWIG_fail;
7553 }
7554 if (obj2) {
7555 {
7556 arg3 = (int)(SWIG_As_int(obj2));
7557 if (SWIG_arg_fail(3)) SWIG_fail;
7558 }
7559 }
7560 {
7561 PyThreadState* __tstate = wxPyBeginAllowThreads();
7562 (arg1)->seek(arg2,arg3);
7563
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 Py_INCREF(Py_None); resultobj = Py_None;
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7575 PyObject *resultobj;
7576 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7577 int result;
7578 PyObject * obj0 = 0 ;
7579 char *kwnames[] = {
7580 (char *) "self", NULL
7581 };
7582
7583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7585 if (SWIG_arg_fail(1)) SWIG_fail;
7586 {
7587 PyThreadState* __tstate = wxPyBeginAllowThreads();
7588 result = (int)(arg1)->tell();
7589
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 {
7594 resultobj = SWIG_From_int((int)(result));
7595 }
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7603 PyObject *resultobj;
7604 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7605 char result;
7606 PyObject * obj0 = 0 ;
7607 char *kwnames[] = {
7608 (char *) "self", NULL
7609 };
7610
7611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7613 if (SWIG_arg_fail(1)) SWIG_fail;
7614 {
7615 PyThreadState* __tstate = wxPyBeginAllowThreads();
7616 result = (char)(arg1)->Peek();
7617
7618 wxPyEndAllowThreads(__tstate);
7619 if (PyErr_Occurred()) SWIG_fail;
7620 }
7621 {
7622 resultobj = SWIG_From_char((char)(result));
7623 }
7624 return resultobj;
7625 fail:
7626 return NULL;
7627 }
7628
7629
7630 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7631 PyObject *resultobj;
7632 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7633 char result;
7634 PyObject * obj0 = 0 ;
7635 char *kwnames[] = {
7636 (char *) "self", NULL
7637 };
7638
7639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7641 if (SWIG_arg_fail(1)) SWIG_fail;
7642 {
7643 PyThreadState* __tstate = wxPyBeginAllowThreads();
7644 result = (char)(arg1)->GetC();
7645
7646 wxPyEndAllowThreads(__tstate);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 {
7650 resultobj = SWIG_From_char((char)(result));
7651 }
7652 return resultobj;
7653 fail:
7654 return NULL;
7655 }
7656
7657
7658 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7659 PyObject *resultobj;
7660 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7661 size_t result;
7662 PyObject * obj0 = 0 ;
7663 char *kwnames[] = {
7664 (char *) "self", NULL
7665 };
7666
7667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7669 if (SWIG_arg_fail(1)) SWIG_fail;
7670 {
7671 PyThreadState* __tstate = wxPyBeginAllowThreads();
7672 result = (size_t)(arg1)->LastRead();
7673
7674 wxPyEndAllowThreads(__tstate);
7675 if (PyErr_Occurred()) SWIG_fail;
7676 }
7677 {
7678 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7679 }
7680 return resultobj;
7681 fail:
7682 return NULL;
7683 }
7684
7685
7686 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7687 PyObject *resultobj;
7688 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7689 bool result;
7690 PyObject * obj0 = 0 ;
7691 char *kwnames[] = {
7692 (char *) "self", NULL
7693 };
7694
7695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7697 if (SWIG_arg_fail(1)) SWIG_fail;
7698 {
7699 PyThreadState* __tstate = wxPyBeginAllowThreads();
7700 result = (bool)(arg1)->CanRead();
7701
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 {
7706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7707 }
7708 return resultobj;
7709 fail:
7710 return NULL;
7711 }
7712
7713
7714 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7715 PyObject *resultobj;
7716 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7717 bool result;
7718 PyObject * obj0 = 0 ;
7719 char *kwnames[] = {
7720 (char *) "self", NULL
7721 };
7722
7723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7725 if (SWIG_arg_fail(1)) SWIG_fail;
7726 {
7727 PyThreadState* __tstate = wxPyBeginAllowThreads();
7728 result = (bool)(arg1)->Eof();
7729
7730 wxPyEndAllowThreads(__tstate);
7731 if (PyErr_Occurred()) SWIG_fail;
7732 }
7733 {
7734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7735 }
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj;
7744 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7745 char arg2 ;
7746 bool result;
7747 PyObject * obj0 = 0 ;
7748 PyObject * obj1 = 0 ;
7749 char *kwnames[] = {
7750 (char *) "self",(char *) "c", NULL
7751 };
7752
7753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7755 if (SWIG_arg_fail(1)) SWIG_fail;
7756 {
7757 arg2 = (char)(SWIG_As_char(obj1));
7758 if (SWIG_arg_fail(2)) SWIG_fail;
7759 }
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 result = (bool)(arg1)->Ungetch(arg2);
7763
7764 wxPyEndAllowThreads(__tstate);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 {
7768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7769 }
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj;
7778 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7779 long arg2 ;
7780 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7781 long result;
7782 PyObject * obj0 = 0 ;
7783 PyObject * obj1 = 0 ;
7784 PyObject * obj2 = 0 ;
7785 char *kwnames[] = {
7786 (char *) "self",(char *) "pos",(char *) "mode", NULL
7787 };
7788
7789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7791 if (SWIG_arg_fail(1)) SWIG_fail;
7792 {
7793 arg2 = (long)(SWIG_As_long(obj1));
7794 if (SWIG_arg_fail(2)) SWIG_fail;
7795 }
7796 if (obj2) {
7797 {
7798 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7799 if (SWIG_arg_fail(3)) SWIG_fail;
7800 }
7801 }
7802 {
7803 PyThreadState* __tstate = wxPyBeginAllowThreads();
7804 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7805
7806 wxPyEndAllowThreads(__tstate);
7807 if (PyErr_Occurred()) SWIG_fail;
7808 }
7809 {
7810 resultobj = SWIG_From_long((long)(result));
7811 }
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7819 PyObject *resultobj;
7820 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7821 long result;
7822 PyObject * obj0 = 0 ;
7823 char *kwnames[] = {
7824 (char *) "self", NULL
7825 };
7826
7827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7829 if (SWIG_arg_fail(1)) SWIG_fail;
7830 {
7831 PyThreadState* __tstate = wxPyBeginAllowThreads();
7832 result = (long)(arg1)->TellI();
7833
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 {
7838 resultobj = SWIG_From_long((long)(result));
7839 }
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7847 PyObject *obj;
7848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7849 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7850 Py_INCREF(obj);
7851 return Py_BuildValue((char *)"");
7852 }
7853 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7854 PyObject *resultobj;
7855 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7856 PyObject *arg2 = (PyObject *) 0 ;
7857 PyObject * obj0 = 0 ;
7858 PyObject * obj1 = 0 ;
7859 char *kwnames[] = {
7860 (char *) "self",(char *) "obj", NULL
7861 };
7862
7863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7865 if (SWIG_arg_fail(1)) SWIG_fail;
7866 arg2 = obj1;
7867 {
7868 PyThreadState* __tstate = wxPyBeginAllowThreads();
7869 wxOutputStream_write(arg1,arg2);
7870
7871 wxPyEndAllowThreads(__tstate);
7872 if (PyErr_Occurred()) SWIG_fail;
7873 }
7874 Py_INCREF(Py_None); resultobj = Py_None;
7875 return resultobj;
7876 fail:
7877 return NULL;
7878 }
7879
7880
7881 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7882 PyObject *obj;
7883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7884 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7885 Py_INCREF(obj);
7886 return Py_BuildValue((char *)"");
7887 }
7888 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj;
7890 wxInputStream *arg1 = (wxInputStream *) 0 ;
7891 wxString *arg2 = 0 ;
7892 wxString *arg3 = 0 ;
7893 wxString *arg4 = 0 ;
7894 wxDateTime arg5 ;
7895 wxFSFile *result;
7896 wxPyInputStream *temp1 ;
7897 bool created1 ;
7898 bool temp2 = false ;
7899 bool temp3 = false ;
7900 bool temp4 = false ;
7901 PyObject * obj0 = 0 ;
7902 PyObject * obj1 = 0 ;
7903 PyObject * obj2 = 0 ;
7904 PyObject * obj3 = 0 ;
7905 PyObject * obj4 = 0 ;
7906 char *kwnames[] = {
7907 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7908 };
7909
7910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7911 {
7912 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7913 arg1 = temp1->m_wxis;
7914 created1 = false;
7915 } else {
7916 PyErr_Clear(); // clear the failure of the wxPyConvert above
7917 arg1 = wxPyCBInputStream_create(obj0, false);
7918 if (arg1 == NULL) {
7919 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7920 SWIG_fail;
7921 }
7922 created1 = true;
7923 }
7924 }
7925 {
7926 arg2 = wxString_in_helper(obj1);
7927 if (arg2 == NULL) SWIG_fail;
7928 temp2 = true;
7929 }
7930 {
7931 arg3 = wxString_in_helper(obj2);
7932 if (arg3 == NULL) SWIG_fail;
7933 temp3 = true;
7934 }
7935 {
7936 arg4 = wxString_in_helper(obj3);
7937 if (arg4 == NULL) SWIG_fail;
7938 temp4 = true;
7939 }
7940 {
7941 wxDateTime * argp;
7942 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7943 if (SWIG_arg_fail(5)) SWIG_fail;
7944 if (argp == NULL) {
7945 SWIG_null_ref("wxDateTime");
7946 }
7947 if (SWIG_arg_fail(5)) SWIG_fail;
7948 arg5 = *argp;
7949 }
7950 {
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7953
7954 wxPyEndAllowThreads(__tstate);
7955 if (PyErr_Occurred()) SWIG_fail;
7956 }
7957 {
7958 resultobj = wxPyMake_wxObject(result, 1);
7959 }
7960 {
7961 if (created1)
7962 delete arg1;
7963 }
7964 {
7965 if (temp2)
7966 delete arg2;
7967 }
7968 {
7969 if (temp3)
7970 delete arg3;
7971 }
7972 {
7973 if (temp4)
7974 delete arg4;
7975 }
7976 return resultobj;
7977 fail:
7978 {
7979 if (created1)
7980 delete arg1;
7981 }
7982 {
7983 if (temp2)
7984 delete arg2;
7985 }
7986 {
7987 if (temp3)
7988 delete arg3;
7989 }
7990 {
7991 if (temp4)
7992 delete arg4;
7993 }
7994 return NULL;
7995 }
7996
7997
7998 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7999 PyObject *resultobj;
8000 wxFSFile *arg1 = (wxFSFile *) 0 ;
8001 PyObject * obj0 = 0 ;
8002 char *kwnames[] = {
8003 (char *) "self", NULL
8004 };
8005
8006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8008 if (SWIG_arg_fail(1)) SWIG_fail;
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 delete arg1;
8012
8013 wxPyEndAllowThreads(__tstate);
8014 if (PyErr_Occurred()) SWIG_fail;
8015 }
8016 Py_INCREF(Py_None); resultobj = Py_None;
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8024 PyObject *resultobj;
8025 wxFSFile *arg1 = (wxFSFile *) 0 ;
8026 wxInputStream *result;
8027 PyObject * obj0 = 0 ;
8028 char *kwnames[] = {
8029 (char *) "self", NULL
8030 };
8031
8032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8034 if (SWIG_arg_fail(1)) SWIG_fail;
8035 {
8036 PyThreadState* __tstate = wxPyBeginAllowThreads();
8037 result = (wxInputStream *)(arg1)->GetStream();
8038
8039 wxPyEndAllowThreads(__tstate);
8040 if (PyErr_Occurred()) SWIG_fail;
8041 }
8042 {
8043 wxPyInputStream * _ptr = NULL;
8044
8045 if (result) {
8046 _ptr = new wxPyInputStream(result);
8047 }
8048 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8049 }
8050 return resultobj;
8051 fail:
8052 return NULL;
8053 }
8054
8055
8056 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8057 PyObject *resultobj;
8058 wxFSFile *arg1 = (wxFSFile *) 0 ;
8059 wxString *result;
8060 PyObject * obj0 = 0 ;
8061 char *kwnames[] = {
8062 (char *) "self", NULL
8063 };
8064
8065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8067 if (SWIG_arg_fail(1)) SWIG_fail;
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 {
8071 wxString const &_result_ref = (arg1)->GetMimeType();
8072 result = (wxString *) &_result_ref;
8073 }
8074
8075 wxPyEndAllowThreads(__tstate);
8076 if (PyErr_Occurred()) SWIG_fail;
8077 }
8078 {
8079 #if wxUSE_UNICODE
8080 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8081 #else
8082 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8083 #endif
8084 }
8085 return resultobj;
8086 fail:
8087 return NULL;
8088 }
8089
8090
8091 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8092 PyObject *resultobj;
8093 wxFSFile *arg1 = (wxFSFile *) 0 ;
8094 wxString *result;
8095 PyObject * obj0 = 0 ;
8096 char *kwnames[] = {
8097 (char *) "self", NULL
8098 };
8099
8100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8102 if (SWIG_arg_fail(1)) SWIG_fail;
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 {
8106 wxString const &_result_ref = (arg1)->GetLocation();
8107 result = (wxString *) &_result_ref;
8108 }
8109
8110 wxPyEndAllowThreads(__tstate);
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 {
8114 #if wxUSE_UNICODE
8115 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8116 #else
8117 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8118 #endif
8119 }
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj;
8128 wxFSFile *arg1 = (wxFSFile *) 0 ;
8129 wxString *result;
8130 PyObject * obj0 = 0 ;
8131 char *kwnames[] = {
8132 (char *) "self", NULL
8133 };
8134
8135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8137 if (SWIG_arg_fail(1)) SWIG_fail;
8138 {
8139 PyThreadState* __tstate = wxPyBeginAllowThreads();
8140 {
8141 wxString const &_result_ref = (arg1)->GetAnchor();
8142 result = (wxString *) &_result_ref;
8143 }
8144
8145 wxPyEndAllowThreads(__tstate);
8146 if (PyErr_Occurred()) SWIG_fail;
8147 }
8148 {
8149 #if wxUSE_UNICODE
8150 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8151 #else
8152 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8153 #endif
8154 }
8155 return resultobj;
8156 fail:
8157 return NULL;
8158 }
8159
8160
8161 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8162 PyObject *resultobj;
8163 wxFSFile *arg1 = (wxFSFile *) 0 ;
8164 wxDateTime result;
8165 PyObject * obj0 = 0 ;
8166 char *kwnames[] = {
8167 (char *) "self", NULL
8168 };
8169
8170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8172 if (SWIG_arg_fail(1)) SWIG_fail;
8173 {
8174 PyThreadState* __tstate = wxPyBeginAllowThreads();
8175 result = (arg1)->GetModificationTime();
8176
8177 wxPyEndAllowThreads(__tstate);
8178 if (PyErr_Occurred()) SWIG_fail;
8179 }
8180 {
8181 wxDateTime * resultptr;
8182 resultptr = new wxDateTime((wxDateTime &)(result));
8183 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8184 }
8185 return resultobj;
8186 fail:
8187 return NULL;
8188 }
8189
8190
8191 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8192 PyObject *obj;
8193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8194 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8195 Py_INCREF(obj);
8196 return Py_BuildValue((char *)"");
8197 }
8198 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8199 PyObject *obj;
8200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8201 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8202 Py_INCREF(obj);
8203 return Py_BuildValue((char *)"");
8204 }
8205 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8206 PyObject *resultobj;
8207 wxPyFileSystemHandler *result;
8208 char *kwnames[] = {
8209 NULL
8210 };
8211
8212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8213 {
8214 PyThreadState* __tstate = wxPyBeginAllowThreads();
8215 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8216
8217 wxPyEndAllowThreads(__tstate);
8218 if (PyErr_Occurred()) SWIG_fail;
8219 }
8220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8221 return resultobj;
8222 fail:
8223 return NULL;
8224 }
8225
8226
8227 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8228 PyObject *resultobj;
8229 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8230 PyObject *arg2 = (PyObject *) 0 ;
8231 PyObject *arg3 = (PyObject *) 0 ;
8232 PyObject * obj0 = 0 ;
8233 PyObject * obj1 = 0 ;
8234 PyObject * obj2 = 0 ;
8235 char *kwnames[] = {
8236 (char *) "self",(char *) "self",(char *) "_class", NULL
8237 };
8238
8239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8241 if (SWIG_arg_fail(1)) SWIG_fail;
8242 arg2 = obj1;
8243 arg3 = obj2;
8244 {
8245 PyThreadState* __tstate = wxPyBeginAllowThreads();
8246 (arg1)->_setCallbackInfo(arg2,arg3);
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 Py_INCREF(Py_None); resultobj = Py_None;
8252 return resultobj;
8253 fail:
8254 return NULL;
8255 }
8256
8257
8258 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj;
8260 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8261 wxString *arg2 = 0 ;
8262 bool result;
8263 bool temp2 = false ;
8264 PyObject * obj0 = 0 ;
8265 PyObject * obj1 = 0 ;
8266 char *kwnames[] = {
8267 (char *) "self",(char *) "location", NULL
8268 };
8269
8270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8272 if (SWIG_arg_fail(1)) SWIG_fail;
8273 {
8274 arg2 = wxString_in_helper(obj1);
8275 if (arg2 == NULL) SWIG_fail;
8276 temp2 = true;
8277 }
8278 {
8279 PyThreadState* __tstate = wxPyBeginAllowThreads();
8280 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8281
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 {
8286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8287 }
8288 {
8289 if (temp2)
8290 delete arg2;
8291 }
8292 return resultobj;
8293 fail:
8294 {
8295 if (temp2)
8296 delete arg2;
8297 }
8298 return NULL;
8299 }
8300
8301
8302 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8303 PyObject *resultobj;
8304 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8305 wxFileSystem *arg2 = 0 ;
8306 wxString *arg3 = 0 ;
8307 wxFSFile *result;
8308 bool temp3 = false ;
8309 PyObject * obj0 = 0 ;
8310 PyObject * obj1 = 0 ;
8311 PyObject * obj2 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self",(char *) "fs",(char *) "location", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 {
8320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8321 if (SWIG_arg_fail(2)) SWIG_fail;
8322 if (arg2 == NULL) {
8323 SWIG_null_ref("wxFileSystem");
8324 }
8325 if (SWIG_arg_fail(2)) SWIG_fail;
8326 }
8327 {
8328 arg3 = wxString_in_helper(obj2);
8329 if (arg3 == NULL) SWIG_fail;
8330 temp3 = true;
8331 }
8332 {
8333 PyThreadState* __tstate = wxPyBeginAllowThreads();
8334 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8335
8336 wxPyEndAllowThreads(__tstate);
8337 if (PyErr_Occurred()) SWIG_fail;
8338 }
8339 {
8340 resultobj = wxPyMake_wxObject(result, 1);
8341 }
8342 {
8343 if (temp3)
8344 delete arg3;
8345 }
8346 return resultobj;
8347 fail:
8348 {
8349 if (temp3)
8350 delete arg3;
8351 }
8352 return NULL;
8353 }
8354
8355
8356 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8357 PyObject *resultobj;
8358 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8359 wxString *arg2 = 0 ;
8360 int arg3 = (int) 0 ;
8361 wxString result;
8362 bool temp2 = false ;
8363 PyObject * obj0 = 0 ;
8364 PyObject * obj1 = 0 ;
8365 PyObject * obj2 = 0 ;
8366 char *kwnames[] = {
8367 (char *) "self",(char *) "spec",(char *) "flags", NULL
8368 };
8369
8370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8372 if (SWIG_arg_fail(1)) SWIG_fail;
8373 {
8374 arg2 = wxString_in_helper(obj1);
8375 if (arg2 == NULL) SWIG_fail;
8376 temp2 = true;
8377 }
8378 if (obj2) {
8379 {
8380 arg3 = (int)(SWIG_As_int(obj2));
8381 if (SWIG_arg_fail(3)) SWIG_fail;
8382 }
8383 }
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8387
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 {
8392 #if wxUSE_UNICODE
8393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8394 #else
8395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8396 #endif
8397 }
8398 {
8399 if (temp2)
8400 delete arg2;
8401 }
8402 return resultobj;
8403 fail:
8404 {
8405 if (temp2)
8406 delete arg2;
8407 }
8408 return NULL;
8409 }
8410
8411
8412 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8413 PyObject *resultobj;
8414 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8415 wxString result;
8416 PyObject * obj0 = 0 ;
8417 char *kwnames[] = {
8418 (char *) "self", NULL
8419 };
8420
8421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8423 if (SWIG_arg_fail(1)) SWIG_fail;
8424 {
8425 PyThreadState* __tstate = wxPyBeginAllowThreads();
8426 result = (arg1)->FindNext();
8427
8428 wxPyEndAllowThreads(__tstate);
8429 if (PyErr_Occurred()) SWIG_fail;
8430 }
8431 {
8432 #if wxUSE_UNICODE
8433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8434 #else
8435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8436 #endif
8437 }
8438 return resultobj;
8439 fail:
8440 return NULL;
8441 }
8442
8443
8444 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8445 PyObject *resultobj;
8446 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8447 wxString *arg2 = 0 ;
8448 wxString result;
8449 bool temp2 = false ;
8450 PyObject * obj0 = 0 ;
8451 PyObject * obj1 = 0 ;
8452 char *kwnames[] = {
8453 (char *) "self",(char *) "location", NULL
8454 };
8455
8456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8458 if (SWIG_arg_fail(1)) SWIG_fail;
8459 {
8460 arg2 = wxString_in_helper(obj1);
8461 if (arg2 == NULL) SWIG_fail;
8462 temp2 = true;
8463 }
8464 {
8465 PyThreadState* __tstate = wxPyBeginAllowThreads();
8466 result = (arg1)->GetProtocol((wxString const &)*arg2);
8467
8468 wxPyEndAllowThreads(__tstate);
8469 if (PyErr_Occurred()) SWIG_fail;
8470 }
8471 {
8472 #if wxUSE_UNICODE
8473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8474 #else
8475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8476 #endif
8477 }
8478 {
8479 if (temp2)
8480 delete arg2;
8481 }
8482 return resultobj;
8483 fail:
8484 {
8485 if (temp2)
8486 delete arg2;
8487 }
8488 return NULL;
8489 }
8490
8491
8492 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8493 PyObject *resultobj;
8494 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8495 wxString *arg2 = 0 ;
8496 wxString result;
8497 bool temp2 = false ;
8498 PyObject * obj0 = 0 ;
8499 PyObject * obj1 = 0 ;
8500 char *kwnames[] = {
8501 (char *) "self",(char *) "location", NULL
8502 };
8503
8504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8506 if (SWIG_arg_fail(1)) SWIG_fail;
8507 {
8508 arg2 = wxString_in_helper(obj1);
8509 if (arg2 == NULL) SWIG_fail;
8510 temp2 = true;
8511 }
8512 {
8513 PyThreadState* __tstate = wxPyBeginAllowThreads();
8514 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8515
8516 wxPyEndAllowThreads(__tstate);
8517 if (PyErr_Occurred()) SWIG_fail;
8518 }
8519 {
8520 #if wxUSE_UNICODE
8521 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8522 #else
8523 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8524 #endif
8525 }
8526 {
8527 if (temp2)
8528 delete arg2;
8529 }
8530 return resultobj;
8531 fail:
8532 {
8533 if (temp2)
8534 delete arg2;
8535 }
8536 return NULL;
8537 }
8538
8539
8540 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj;
8542 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8543 wxString *arg2 = 0 ;
8544 wxString result;
8545 bool temp2 = false ;
8546 PyObject * obj0 = 0 ;
8547 PyObject * obj1 = 0 ;
8548 char *kwnames[] = {
8549 (char *) "self",(char *) "location", NULL
8550 };
8551
8552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8554 if (SWIG_arg_fail(1)) SWIG_fail;
8555 {
8556 arg2 = wxString_in_helper(obj1);
8557 if (arg2 == NULL) SWIG_fail;
8558 temp2 = true;
8559 }
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (arg1)->GetAnchor((wxString const &)*arg2);
8563
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 {
8568 #if wxUSE_UNICODE
8569 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8570 #else
8571 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8572 #endif
8573 }
8574 {
8575 if (temp2)
8576 delete arg2;
8577 }
8578 return resultobj;
8579 fail:
8580 {
8581 if (temp2)
8582 delete arg2;
8583 }
8584 return NULL;
8585 }
8586
8587
8588 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8589 PyObject *resultobj;
8590 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8591 wxString *arg2 = 0 ;
8592 wxString result;
8593 bool temp2 = false ;
8594 PyObject * obj0 = 0 ;
8595 PyObject * obj1 = 0 ;
8596 char *kwnames[] = {
8597 (char *) "self",(char *) "location", NULL
8598 };
8599
8600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8602 if (SWIG_arg_fail(1)) SWIG_fail;
8603 {
8604 arg2 = wxString_in_helper(obj1);
8605 if (arg2 == NULL) SWIG_fail;
8606 temp2 = true;
8607 }
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8611
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 {
8616 #if wxUSE_UNICODE
8617 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8618 #else
8619 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8620 #endif
8621 }
8622 {
8623 if (temp2)
8624 delete arg2;
8625 }
8626 return resultobj;
8627 fail:
8628 {
8629 if (temp2)
8630 delete arg2;
8631 }
8632 return NULL;
8633 }
8634
8635
8636 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8637 PyObject *resultobj;
8638 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8639 wxString *arg2 = 0 ;
8640 wxString result;
8641 bool temp2 = false ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char *kwnames[] = {
8645 (char *) "self",(char *) "location", NULL
8646 };
8647
8648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8650 if (SWIG_arg_fail(1)) SWIG_fail;
8651 {
8652 arg2 = wxString_in_helper(obj1);
8653 if (arg2 == NULL) SWIG_fail;
8654 temp2 = true;
8655 }
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8659
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 {
8664 #if wxUSE_UNICODE
8665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8666 #else
8667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8668 #endif
8669 }
8670 {
8671 if (temp2)
8672 delete arg2;
8673 }
8674 return resultobj;
8675 fail:
8676 {
8677 if (temp2)
8678 delete arg2;
8679 }
8680 return NULL;
8681 }
8682
8683
8684 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8685 PyObject *obj;
8686 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8687 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8688 Py_INCREF(obj);
8689 return Py_BuildValue((char *)"");
8690 }
8691 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8692 PyObject *resultobj;
8693 wxFileSystem *result;
8694 char *kwnames[] = {
8695 NULL
8696 };
8697
8698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8699 {
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 result = (wxFileSystem *)new wxFileSystem();
8702
8703 wxPyEndAllowThreads(__tstate);
8704 if (PyErr_Occurred()) SWIG_fail;
8705 }
8706 {
8707 resultobj = wxPyMake_wxObject(result, 1);
8708 }
8709 return resultobj;
8710 fail:
8711 return NULL;
8712 }
8713
8714
8715 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8716 PyObject *resultobj;
8717 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8718 PyObject * obj0 = 0 ;
8719 char *kwnames[] = {
8720 (char *) "self", NULL
8721 };
8722
8723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8725 if (SWIG_arg_fail(1)) SWIG_fail;
8726 {
8727 PyThreadState* __tstate = wxPyBeginAllowThreads();
8728 delete arg1;
8729
8730 wxPyEndAllowThreads(__tstate);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 Py_INCREF(Py_None); resultobj = Py_None;
8734 return resultobj;
8735 fail:
8736 return NULL;
8737 }
8738
8739
8740 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8741 PyObject *resultobj;
8742 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8743 wxString *arg2 = 0 ;
8744 bool arg3 = (bool) false ;
8745 bool temp2 = false ;
8746 PyObject * obj0 = 0 ;
8747 PyObject * obj1 = 0 ;
8748 PyObject * obj2 = 0 ;
8749 char *kwnames[] = {
8750 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8751 };
8752
8753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8755 if (SWIG_arg_fail(1)) SWIG_fail;
8756 {
8757 arg2 = wxString_in_helper(obj1);
8758 if (arg2 == NULL) SWIG_fail;
8759 temp2 = true;
8760 }
8761 if (obj2) {
8762 {
8763 arg3 = (bool)(SWIG_As_bool(obj2));
8764 if (SWIG_arg_fail(3)) SWIG_fail;
8765 }
8766 }
8767 {
8768 PyThreadState* __tstate = wxPyBeginAllowThreads();
8769 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8770
8771 wxPyEndAllowThreads(__tstate);
8772 if (PyErr_Occurred()) SWIG_fail;
8773 }
8774 Py_INCREF(Py_None); resultobj = Py_None;
8775 {
8776 if (temp2)
8777 delete arg2;
8778 }
8779 return resultobj;
8780 fail:
8781 {
8782 if (temp2)
8783 delete arg2;
8784 }
8785 return NULL;
8786 }
8787
8788
8789 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj;
8791 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8792 wxString result;
8793 PyObject * obj0 = 0 ;
8794 char *kwnames[] = {
8795 (char *) "self", NULL
8796 };
8797
8798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8800 if (SWIG_arg_fail(1)) SWIG_fail;
8801 {
8802 PyThreadState* __tstate = wxPyBeginAllowThreads();
8803 result = (arg1)->GetPath();
8804
8805 wxPyEndAllowThreads(__tstate);
8806 if (PyErr_Occurred()) SWIG_fail;
8807 }
8808 {
8809 #if wxUSE_UNICODE
8810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8811 #else
8812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8813 #endif
8814 }
8815 return resultobj;
8816 fail:
8817 return NULL;
8818 }
8819
8820
8821 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8822 PyObject *resultobj;
8823 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8824 wxString *arg2 = 0 ;
8825 wxFSFile *result;
8826 bool temp2 = false ;
8827 PyObject * obj0 = 0 ;
8828 PyObject * obj1 = 0 ;
8829 char *kwnames[] = {
8830 (char *) "self",(char *) "location", NULL
8831 };
8832
8833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8835 if (SWIG_arg_fail(1)) SWIG_fail;
8836 {
8837 arg2 = wxString_in_helper(obj1);
8838 if (arg2 == NULL) SWIG_fail;
8839 temp2 = true;
8840 }
8841 {
8842 PyThreadState* __tstate = wxPyBeginAllowThreads();
8843 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8844
8845 wxPyEndAllowThreads(__tstate);
8846 if (PyErr_Occurred()) SWIG_fail;
8847 }
8848 {
8849 resultobj = wxPyMake_wxObject(result, 1);
8850 }
8851 {
8852 if (temp2)
8853 delete arg2;
8854 }
8855 return resultobj;
8856 fail:
8857 {
8858 if (temp2)
8859 delete arg2;
8860 }
8861 return NULL;
8862 }
8863
8864
8865 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8866 PyObject *resultobj;
8867 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8868 wxString *arg2 = 0 ;
8869 int arg3 = (int) 0 ;
8870 wxString result;
8871 bool temp2 = false ;
8872 PyObject * obj0 = 0 ;
8873 PyObject * obj1 = 0 ;
8874 PyObject * obj2 = 0 ;
8875 char *kwnames[] = {
8876 (char *) "self",(char *) "spec",(char *) "flags", NULL
8877 };
8878
8879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8881 if (SWIG_arg_fail(1)) SWIG_fail;
8882 {
8883 arg2 = wxString_in_helper(obj1);
8884 if (arg2 == NULL) SWIG_fail;
8885 temp2 = true;
8886 }
8887 if (obj2) {
8888 {
8889 arg3 = (int)(SWIG_As_int(obj2));
8890 if (SWIG_arg_fail(3)) SWIG_fail;
8891 }
8892 }
8893 {
8894 PyThreadState* __tstate = wxPyBeginAllowThreads();
8895 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8896
8897 wxPyEndAllowThreads(__tstate);
8898 if (PyErr_Occurred()) SWIG_fail;
8899 }
8900 {
8901 #if wxUSE_UNICODE
8902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8903 #else
8904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8905 #endif
8906 }
8907 {
8908 if (temp2)
8909 delete arg2;
8910 }
8911 return resultobj;
8912 fail:
8913 {
8914 if (temp2)
8915 delete arg2;
8916 }
8917 return NULL;
8918 }
8919
8920
8921 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8922 PyObject *resultobj;
8923 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8924 wxString result;
8925 PyObject * obj0 = 0 ;
8926 char *kwnames[] = {
8927 (char *) "self", NULL
8928 };
8929
8930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8932 if (SWIG_arg_fail(1)) SWIG_fail;
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 result = (arg1)->FindNext();
8936
8937 wxPyEndAllowThreads(__tstate);
8938 if (PyErr_Occurred()) SWIG_fail;
8939 }
8940 {
8941 #if wxUSE_UNICODE
8942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8943 #else
8944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8945 #endif
8946 }
8947 return resultobj;
8948 fail:
8949 return NULL;
8950 }
8951
8952
8953 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8954 PyObject *resultobj;
8955 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8956 PyObject * obj0 = 0 ;
8957 char *kwnames[] = {
8958 (char *) "handler", NULL
8959 };
8960
8961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8963 if (SWIG_arg_fail(1)) SWIG_fail;
8964 {
8965 PyThreadState* __tstate = wxPyBeginAllowThreads();
8966 wxFileSystem::AddHandler(arg1);
8967
8968 wxPyEndAllowThreads(__tstate);
8969 if (PyErr_Occurred()) SWIG_fail;
8970 }
8971 Py_INCREF(Py_None); resultobj = Py_None;
8972 return resultobj;
8973 fail:
8974 return NULL;
8975 }
8976
8977
8978 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj;
8980 char *kwnames[] = {
8981 NULL
8982 };
8983
8984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8985 {
8986 PyThreadState* __tstate = wxPyBeginAllowThreads();
8987 wxFileSystem::CleanUpHandlers();
8988
8989 wxPyEndAllowThreads(__tstate);
8990 if (PyErr_Occurred()) SWIG_fail;
8991 }
8992 Py_INCREF(Py_None); resultobj = Py_None;
8993 return resultobj;
8994 fail:
8995 return NULL;
8996 }
8997
8998
8999 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9000 PyObject *resultobj;
9001 wxString *arg1 = 0 ;
9002 wxString result;
9003 bool temp1 = false ;
9004 PyObject * obj0 = 0 ;
9005 char *kwnames[] = {
9006 (char *) "filename", NULL
9007 };
9008
9009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9010 {
9011 arg1 = wxString_in_helper(obj0);
9012 if (arg1 == NULL) SWIG_fail;
9013 temp1 = true;
9014 }
9015 {
9016 PyThreadState* __tstate = wxPyBeginAllowThreads();
9017 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9018
9019 wxPyEndAllowThreads(__tstate);
9020 if (PyErr_Occurred()) SWIG_fail;
9021 }
9022 {
9023 #if wxUSE_UNICODE
9024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9025 #else
9026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9027 #endif
9028 }
9029 {
9030 if (temp1)
9031 delete arg1;
9032 }
9033 return resultobj;
9034 fail:
9035 {
9036 if (temp1)
9037 delete arg1;
9038 }
9039 return NULL;
9040 }
9041
9042
9043 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj;
9045 wxString *arg1 = 0 ;
9046 wxString result;
9047 bool temp1 = false ;
9048 PyObject * obj0 = 0 ;
9049 char *kwnames[] = {
9050 (char *) "url", NULL
9051 };
9052
9053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9054 {
9055 arg1 = wxString_in_helper(obj0);
9056 if (arg1 == NULL) SWIG_fail;
9057 temp1 = true;
9058 }
9059 {
9060 PyThreadState* __tstate = wxPyBeginAllowThreads();
9061 result = FileSystem_URLToFileName((wxString const &)*arg1);
9062
9063 wxPyEndAllowThreads(__tstate);
9064 if (PyErr_Occurred()) SWIG_fail;
9065 }
9066 {
9067 #if wxUSE_UNICODE
9068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9069 #else
9070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9071 #endif
9072 }
9073 {
9074 if (temp1)
9075 delete arg1;
9076 }
9077 return resultobj;
9078 fail:
9079 {
9080 if (temp1)
9081 delete arg1;
9082 }
9083 return NULL;
9084 }
9085
9086
9087 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9088 PyObject *obj;
9089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9090 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9091 Py_INCREF(obj);
9092 return Py_BuildValue((char *)"");
9093 }
9094 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9095 PyObject *resultobj;
9096 wxInternetFSHandler *result;
9097 char *kwnames[] = {
9098 NULL
9099 };
9100
9101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9105
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj;
9118 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9119 wxString *arg2 = 0 ;
9120 bool result;
9121 bool temp2 = false ;
9122 PyObject * obj0 = 0 ;
9123 PyObject * obj1 = 0 ;
9124 char *kwnames[] = {
9125 (char *) "self",(char *) "location", NULL
9126 };
9127
9128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9130 if (SWIG_arg_fail(1)) SWIG_fail;
9131 {
9132 arg2 = wxString_in_helper(obj1);
9133 if (arg2 == NULL) SWIG_fail;
9134 temp2 = true;
9135 }
9136 {
9137 PyThreadState* __tstate = wxPyBeginAllowThreads();
9138 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9139
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 {
9144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9145 }
9146 {
9147 if (temp2)
9148 delete arg2;
9149 }
9150 return resultobj;
9151 fail:
9152 {
9153 if (temp2)
9154 delete arg2;
9155 }
9156 return NULL;
9157 }
9158
9159
9160 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj;
9162 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9163 wxFileSystem *arg2 = 0 ;
9164 wxString *arg3 = 0 ;
9165 wxFSFile *result;
9166 bool temp3 = false ;
9167 PyObject * obj0 = 0 ;
9168 PyObject * obj1 = 0 ;
9169 PyObject * obj2 = 0 ;
9170 char *kwnames[] = {
9171 (char *) "self",(char *) "fs",(char *) "location", NULL
9172 };
9173
9174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9176 if (SWIG_arg_fail(1)) SWIG_fail;
9177 {
9178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9179 if (SWIG_arg_fail(2)) SWIG_fail;
9180 if (arg2 == NULL) {
9181 SWIG_null_ref("wxFileSystem");
9182 }
9183 if (SWIG_arg_fail(2)) SWIG_fail;
9184 }
9185 {
9186 arg3 = wxString_in_helper(obj2);
9187 if (arg3 == NULL) SWIG_fail;
9188 temp3 = true;
9189 }
9190 {
9191 PyThreadState* __tstate = wxPyBeginAllowThreads();
9192 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9193
9194 wxPyEndAllowThreads(__tstate);
9195 if (PyErr_Occurred()) SWIG_fail;
9196 }
9197 {
9198 resultobj = wxPyMake_wxObject(result, 1);
9199 }
9200 {
9201 if (temp3)
9202 delete arg3;
9203 }
9204 return resultobj;
9205 fail:
9206 {
9207 if (temp3)
9208 delete arg3;
9209 }
9210 return NULL;
9211 }
9212
9213
9214 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9215 PyObject *obj;
9216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9217 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9218 Py_INCREF(obj);
9219 return Py_BuildValue((char *)"");
9220 }
9221 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9222 PyObject *resultobj;
9223 wxZipFSHandler *result;
9224 char *kwnames[] = {
9225 NULL
9226 };
9227
9228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (wxZipFSHandler *)new wxZipFSHandler();
9232
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9244 PyObject *resultobj;
9245 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9246 wxString *arg2 = 0 ;
9247 bool result;
9248 bool temp2 = false ;
9249 PyObject * obj0 = 0 ;
9250 PyObject * obj1 = 0 ;
9251 char *kwnames[] = {
9252 (char *) "self",(char *) "location", NULL
9253 };
9254
9255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9257 if (SWIG_arg_fail(1)) SWIG_fail;
9258 {
9259 arg2 = wxString_in_helper(obj1);
9260 if (arg2 == NULL) SWIG_fail;
9261 temp2 = true;
9262 }
9263 {
9264 PyThreadState* __tstate = wxPyBeginAllowThreads();
9265 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9266
9267 wxPyEndAllowThreads(__tstate);
9268 if (PyErr_Occurred()) SWIG_fail;
9269 }
9270 {
9271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9272 }
9273 {
9274 if (temp2)
9275 delete arg2;
9276 }
9277 return resultobj;
9278 fail:
9279 {
9280 if (temp2)
9281 delete arg2;
9282 }
9283 return NULL;
9284 }
9285
9286
9287 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9288 PyObject *resultobj;
9289 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9290 wxFileSystem *arg2 = 0 ;
9291 wxString *arg3 = 0 ;
9292 wxFSFile *result;
9293 bool temp3 = false ;
9294 PyObject * obj0 = 0 ;
9295 PyObject * obj1 = 0 ;
9296 PyObject * obj2 = 0 ;
9297 char *kwnames[] = {
9298 (char *) "self",(char *) "fs",(char *) "location", NULL
9299 };
9300
9301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9303 if (SWIG_arg_fail(1)) SWIG_fail;
9304 {
9305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9306 if (SWIG_arg_fail(2)) SWIG_fail;
9307 if (arg2 == NULL) {
9308 SWIG_null_ref("wxFileSystem");
9309 }
9310 if (SWIG_arg_fail(2)) SWIG_fail;
9311 }
9312 {
9313 arg3 = wxString_in_helper(obj2);
9314 if (arg3 == NULL) SWIG_fail;
9315 temp3 = true;
9316 }
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9320
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 {
9325 resultobj = wxPyMake_wxObject(result, 1);
9326 }
9327 {
9328 if (temp3)
9329 delete arg3;
9330 }
9331 return resultobj;
9332 fail:
9333 {
9334 if (temp3)
9335 delete arg3;
9336 }
9337 return NULL;
9338 }
9339
9340
9341 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9342 PyObject *resultobj;
9343 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9344 wxString *arg2 = 0 ;
9345 int arg3 = (int) 0 ;
9346 wxString result;
9347 bool temp2 = false ;
9348 PyObject * obj0 = 0 ;
9349 PyObject * obj1 = 0 ;
9350 PyObject * obj2 = 0 ;
9351 char *kwnames[] = {
9352 (char *) "self",(char *) "spec",(char *) "flags", NULL
9353 };
9354
9355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9357 if (SWIG_arg_fail(1)) SWIG_fail;
9358 {
9359 arg2 = wxString_in_helper(obj1);
9360 if (arg2 == NULL) SWIG_fail;
9361 temp2 = true;
9362 }
9363 if (obj2) {
9364 {
9365 arg3 = (int)(SWIG_As_int(obj2));
9366 if (SWIG_arg_fail(3)) SWIG_fail;
9367 }
9368 }
9369 {
9370 PyThreadState* __tstate = wxPyBeginAllowThreads();
9371 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9372
9373 wxPyEndAllowThreads(__tstate);
9374 if (PyErr_Occurred()) SWIG_fail;
9375 }
9376 {
9377 #if wxUSE_UNICODE
9378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9379 #else
9380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9381 #endif
9382 }
9383 {
9384 if (temp2)
9385 delete arg2;
9386 }
9387 return resultobj;
9388 fail:
9389 {
9390 if (temp2)
9391 delete arg2;
9392 }
9393 return NULL;
9394 }
9395
9396
9397 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj;
9399 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9400 wxString result;
9401 PyObject * obj0 = 0 ;
9402 char *kwnames[] = {
9403 (char *) "self", NULL
9404 };
9405
9406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9408 if (SWIG_arg_fail(1)) SWIG_fail;
9409 {
9410 PyThreadState* __tstate = wxPyBeginAllowThreads();
9411 result = (arg1)->FindNext();
9412
9413 wxPyEndAllowThreads(__tstate);
9414 if (PyErr_Occurred()) SWIG_fail;
9415 }
9416 {
9417 #if wxUSE_UNICODE
9418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9419 #else
9420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9421 #endif
9422 }
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9430 PyObject *obj;
9431 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9432 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9433 Py_INCREF(obj);
9434 return Py_BuildValue((char *)"");
9435 }
9436 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9437 PyObject *resultobj;
9438 wxString *arg1 = 0 ;
9439 wxImage *arg2 = 0 ;
9440 long arg3 ;
9441 bool temp1 = false ;
9442 PyObject * obj0 = 0 ;
9443 PyObject * obj1 = 0 ;
9444 PyObject * obj2 = 0 ;
9445 char *kwnames[] = {
9446 (char *) "filename",(char *) "image",(char *) "type", NULL
9447 };
9448
9449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9450 {
9451 arg1 = wxString_in_helper(obj0);
9452 if (arg1 == NULL) SWIG_fail;
9453 temp1 = true;
9454 }
9455 {
9456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9457 if (SWIG_arg_fail(2)) SWIG_fail;
9458 if (arg2 == NULL) {
9459 SWIG_null_ref("wxImage");
9460 }
9461 if (SWIG_arg_fail(2)) SWIG_fail;
9462 }
9463 {
9464 arg3 = (long)(SWIG_As_long(obj2));
9465 if (SWIG_arg_fail(3)) SWIG_fail;
9466 }
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9470
9471 wxPyEndAllowThreads(__tstate);
9472 if (PyErr_Occurred()) SWIG_fail;
9473 }
9474 Py_INCREF(Py_None); resultobj = Py_None;
9475 {
9476 if (temp1)
9477 delete arg1;
9478 }
9479 return resultobj;
9480 fail:
9481 {
9482 if (temp1)
9483 delete arg1;
9484 }
9485 return NULL;
9486 }
9487
9488
9489 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj;
9491 wxString *arg1 = 0 ;
9492 wxBitmap *arg2 = 0 ;
9493 long arg3 ;
9494 bool temp1 = false ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 PyObject * obj2 = 0 ;
9498 char *kwnames[] = {
9499 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9500 };
9501
9502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9503 {
9504 arg1 = wxString_in_helper(obj0);
9505 if (arg1 == NULL) SWIG_fail;
9506 temp1 = true;
9507 }
9508 {
9509 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9510 if (SWIG_arg_fail(2)) SWIG_fail;
9511 if (arg2 == NULL) {
9512 SWIG_null_ref("wxBitmap");
9513 }
9514 if (SWIG_arg_fail(2)) SWIG_fail;
9515 }
9516 {
9517 arg3 = (long)(SWIG_As_long(obj2));
9518 if (SWIG_arg_fail(3)) SWIG_fail;
9519 }
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 Py_INCREF(Py_None); resultobj = Py_None;
9528 {
9529 if (temp1)
9530 delete arg1;
9531 }
9532 return resultobj;
9533 fail:
9534 {
9535 if (temp1)
9536 delete arg1;
9537 }
9538 return NULL;
9539 }
9540
9541
9542 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9543 PyObject *resultobj;
9544 wxString *arg1 = 0 ;
9545 PyObject *arg2 = (PyObject *) 0 ;
9546 bool temp1 = false ;
9547 PyObject * obj0 = 0 ;
9548 PyObject * obj1 = 0 ;
9549 char *kwnames[] = {
9550 (char *) "filename",(char *) "data", NULL
9551 };
9552
9553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9554 {
9555 arg1 = wxString_in_helper(obj0);
9556 if (arg1 == NULL) SWIG_fail;
9557 temp1 = true;
9558 }
9559 arg2 = obj1;
9560 {
9561 PyThreadState* __tstate = wxPyBeginAllowThreads();
9562 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9563
9564 wxPyEndAllowThreads(__tstate);
9565 if (PyErr_Occurred()) SWIG_fail;
9566 }
9567 Py_INCREF(Py_None); resultobj = Py_None;
9568 {
9569 if (temp1)
9570 delete arg1;
9571 }
9572 return resultobj;
9573 fail:
9574 {
9575 if (temp1)
9576 delete arg1;
9577 }
9578 return NULL;
9579 }
9580
9581
9582 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9583 PyObject *resultobj;
9584 wxMemoryFSHandler *result;
9585 char *kwnames[] = {
9586 NULL
9587 };
9588
9589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9590 {
9591 PyThreadState* __tstate = wxPyBeginAllowThreads();
9592 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9593
9594 wxPyEndAllowThreads(__tstate);
9595 if (PyErr_Occurred()) SWIG_fail;
9596 }
9597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9598 return resultobj;
9599 fail:
9600 return NULL;
9601 }
9602
9603
9604 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9605 PyObject *resultobj;
9606 wxString *arg1 = 0 ;
9607 bool temp1 = false ;
9608 PyObject * obj0 = 0 ;
9609 char *kwnames[] = {
9610 (char *) "filename", NULL
9611 };
9612
9613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9614 {
9615 arg1 = wxString_in_helper(obj0);
9616 if (arg1 == NULL) SWIG_fail;
9617 temp1 = true;
9618 }
9619 {
9620 PyThreadState* __tstate = wxPyBeginAllowThreads();
9621 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9622
9623 wxPyEndAllowThreads(__tstate);
9624 if (PyErr_Occurred()) SWIG_fail;
9625 }
9626 Py_INCREF(Py_None); resultobj = Py_None;
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return resultobj;
9632 fail:
9633 {
9634 if (temp1)
9635 delete arg1;
9636 }
9637 return NULL;
9638 }
9639
9640
9641 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj;
9643 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9644 wxString *arg2 = 0 ;
9645 bool result;
9646 bool temp2 = false ;
9647 PyObject * obj0 = 0 ;
9648 PyObject * obj1 = 0 ;
9649 char *kwnames[] = {
9650 (char *) "self",(char *) "location", NULL
9651 };
9652
9653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9655 if (SWIG_arg_fail(1)) SWIG_fail;
9656 {
9657 arg2 = wxString_in_helper(obj1);
9658 if (arg2 == NULL) SWIG_fail;
9659 temp2 = true;
9660 }
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9664
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 {
9669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9670 }
9671 {
9672 if (temp2)
9673 delete arg2;
9674 }
9675 return resultobj;
9676 fail:
9677 {
9678 if (temp2)
9679 delete arg2;
9680 }
9681 return NULL;
9682 }
9683
9684
9685 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj;
9687 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9688 wxFileSystem *arg2 = 0 ;
9689 wxString *arg3 = 0 ;
9690 wxFSFile *result;
9691 bool temp3 = false ;
9692 PyObject * obj0 = 0 ;
9693 PyObject * obj1 = 0 ;
9694 PyObject * obj2 = 0 ;
9695 char *kwnames[] = {
9696 (char *) "self",(char *) "fs",(char *) "location", NULL
9697 };
9698
9699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9701 if (SWIG_arg_fail(1)) SWIG_fail;
9702 {
9703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9704 if (SWIG_arg_fail(2)) SWIG_fail;
9705 if (arg2 == NULL) {
9706 SWIG_null_ref("wxFileSystem");
9707 }
9708 if (SWIG_arg_fail(2)) SWIG_fail;
9709 }
9710 {
9711 arg3 = wxString_in_helper(obj2);
9712 if (arg3 == NULL) SWIG_fail;
9713 temp3 = true;
9714 }
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 {
9723 resultobj = wxPyMake_wxObject(result, 1);
9724 }
9725 {
9726 if (temp3)
9727 delete arg3;
9728 }
9729 return resultobj;
9730 fail:
9731 {
9732 if (temp3)
9733 delete arg3;
9734 }
9735 return NULL;
9736 }
9737
9738
9739 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9740 PyObject *resultobj;
9741 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9742 wxString *arg2 = 0 ;
9743 int arg3 = (int) 0 ;
9744 wxString result;
9745 bool temp2 = false ;
9746 PyObject * obj0 = 0 ;
9747 PyObject * obj1 = 0 ;
9748 PyObject * obj2 = 0 ;
9749 char *kwnames[] = {
9750 (char *) "self",(char *) "spec",(char *) "flags", NULL
9751 };
9752
9753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9755 if (SWIG_arg_fail(1)) SWIG_fail;
9756 {
9757 arg2 = wxString_in_helper(obj1);
9758 if (arg2 == NULL) SWIG_fail;
9759 temp2 = true;
9760 }
9761 if (obj2) {
9762 {
9763 arg3 = (int)(SWIG_As_int(obj2));
9764 if (SWIG_arg_fail(3)) SWIG_fail;
9765 }
9766 }
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9770
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 {
9775 #if wxUSE_UNICODE
9776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9777 #else
9778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9779 #endif
9780 }
9781 {
9782 if (temp2)
9783 delete arg2;
9784 }
9785 return resultobj;
9786 fail:
9787 {
9788 if (temp2)
9789 delete arg2;
9790 }
9791 return NULL;
9792 }
9793
9794
9795 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9796 PyObject *resultobj;
9797 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9798 wxString result;
9799 PyObject * obj0 = 0 ;
9800 char *kwnames[] = {
9801 (char *) "self", NULL
9802 };
9803
9804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9806 if (SWIG_arg_fail(1)) SWIG_fail;
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 result = (arg1)->FindNext();
9810
9811 wxPyEndAllowThreads(__tstate);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 {
9815 #if wxUSE_UNICODE
9816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9817 #else
9818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9819 #endif
9820 }
9821 return resultobj;
9822 fail:
9823 return NULL;
9824 }
9825
9826
9827 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9828 PyObject *obj;
9829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9830 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9831 Py_INCREF(obj);
9832 return Py_BuildValue((char *)"");
9833 }
9834 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9835 PyObject *resultobj;
9836 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9837 wxString result;
9838 PyObject * obj0 = 0 ;
9839 char *kwnames[] = {
9840 (char *) "self", NULL
9841 };
9842
9843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9845 if (SWIG_arg_fail(1)) SWIG_fail;
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (arg1)->GetName();
9849
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 {
9854 #if wxUSE_UNICODE
9855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9856 #else
9857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9858 #endif
9859 }
9860 return resultobj;
9861 fail:
9862 return NULL;
9863 }
9864
9865
9866 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9867 PyObject *resultobj;
9868 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9869 wxString result;
9870 PyObject * obj0 = 0 ;
9871 char *kwnames[] = {
9872 (char *) "self", NULL
9873 };
9874
9875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9877 if (SWIG_arg_fail(1)) SWIG_fail;
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 result = (arg1)->GetExtension();
9881
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 {
9886 #if wxUSE_UNICODE
9887 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9888 #else
9889 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9890 #endif
9891 }
9892 return resultobj;
9893 fail:
9894 return NULL;
9895 }
9896
9897
9898 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9899 PyObject *resultobj;
9900 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9901 long result;
9902 PyObject * obj0 = 0 ;
9903 char *kwnames[] = {
9904 (char *) "self", NULL
9905 };
9906
9907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9909 if (SWIG_arg_fail(1)) SWIG_fail;
9910 {
9911 PyThreadState* __tstate = wxPyBeginAllowThreads();
9912 result = (long)(arg1)->GetType();
9913
9914 wxPyEndAllowThreads(__tstate);
9915 if (PyErr_Occurred()) SWIG_fail;
9916 }
9917 {
9918 resultobj = SWIG_From_long((long)(result));
9919 }
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9927 PyObject *resultobj;
9928 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9929 wxString result;
9930 PyObject * obj0 = 0 ;
9931 char *kwnames[] = {
9932 (char *) "self", NULL
9933 };
9934
9935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9937 if (SWIG_arg_fail(1)) SWIG_fail;
9938 {
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 result = (arg1)->GetMimeType();
9941
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 {
9946 #if wxUSE_UNICODE
9947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9948 #else
9949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9950 #endif
9951 }
9952 return resultobj;
9953 fail:
9954 return NULL;
9955 }
9956
9957
9958 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9959 PyObject *resultobj;
9960 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9961 wxString *arg2 = 0 ;
9962 bool result;
9963 bool temp2 = false ;
9964 PyObject * obj0 = 0 ;
9965 PyObject * obj1 = 0 ;
9966 char *kwnames[] = {
9967 (char *) "self",(char *) "name", NULL
9968 };
9969
9970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9972 if (SWIG_arg_fail(1)) SWIG_fail;
9973 {
9974 arg2 = wxString_in_helper(obj1);
9975 if (arg2 == NULL) SWIG_fail;
9976 temp2 = true;
9977 }
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9981
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 {
9986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9987 }
9988 {
9989 if (temp2)
9990 delete arg2;
9991 }
9992 return resultobj;
9993 fail:
9994 {
9995 if (temp2)
9996 delete arg2;
9997 }
9998 return NULL;
9999 }
10000
10001
10002 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10003 PyObject *resultobj;
10004 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10005 wxString *arg2 = 0 ;
10006 bool temp2 = false ;
10007 PyObject * obj0 = 0 ;
10008 PyObject * obj1 = 0 ;
10009 char *kwnames[] = {
10010 (char *) "self",(char *) "name", NULL
10011 };
10012
10013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10015 if (SWIG_arg_fail(1)) SWIG_fail;
10016 {
10017 arg2 = wxString_in_helper(obj1);
10018 if (arg2 == NULL) SWIG_fail;
10019 temp2 = true;
10020 }
10021 {
10022 PyThreadState* __tstate = wxPyBeginAllowThreads();
10023 (arg1)->SetName((wxString const &)*arg2);
10024
10025 wxPyEndAllowThreads(__tstate);
10026 if (PyErr_Occurred()) SWIG_fail;
10027 }
10028 Py_INCREF(Py_None); resultobj = Py_None;
10029 {
10030 if (temp2)
10031 delete arg2;
10032 }
10033 return resultobj;
10034 fail:
10035 {
10036 if (temp2)
10037 delete arg2;
10038 }
10039 return NULL;
10040 }
10041
10042
10043 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10044 PyObject *resultobj;
10045 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10046 wxString *arg2 = 0 ;
10047 bool temp2 = false ;
10048 PyObject * obj0 = 0 ;
10049 PyObject * obj1 = 0 ;
10050 char *kwnames[] = {
10051 (char *) "self",(char *) "extension", NULL
10052 };
10053
10054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10056 if (SWIG_arg_fail(1)) SWIG_fail;
10057 {
10058 arg2 = wxString_in_helper(obj1);
10059 if (arg2 == NULL) SWIG_fail;
10060 temp2 = true;
10061 }
10062 {
10063 PyThreadState* __tstate = wxPyBeginAllowThreads();
10064 (arg1)->SetExtension((wxString const &)*arg2);
10065
10066 wxPyEndAllowThreads(__tstate);
10067 if (PyErr_Occurred()) SWIG_fail;
10068 }
10069 Py_INCREF(Py_None); resultobj = Py_None;
10070 {
10071 if (temp2)
10072 delete arg2;
10073 }
10074 return resultobj;
10075 fail:
10076 {
10077 if (temp2)
10078 delete arg2;
10079 }
10080 return NULL;
10081 }
10082
10083
10084 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10085 PyObject *resultobj;
10086 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10087 long arg2 ;
10088 PyObject * obj0 = 0 ;
10089 PyObject * obj1 = 0 ;
10090 char *kwnames[] = {
10091 (char *) "self",(char *) "type", NULL
10092 };
10093
10094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10096 if (SWIG_arg_fail(1)) SWIG_fail;
10097 {
10098 arg2 = (long)(SWIG_As_long(obj1));
10099 if (SWIG_arg_fail(2)) SWIG_fail;
10100 }
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 (arg1)->SetType(arg2);
10104
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 Py_INCREF(Py_None); resultobj = Py_None;
10109 return resultobj;
10110 fail:
10111 return NULL;
10112 }
10113
10114
10115 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10116 PyObject *resultobj;
10117 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10118 wxString *arg2 = 0 ;
10119 bool temp2 = false ;
10120 PyObject * obj0 = 0 ;
10121 PyObject * obj1 = 0 ;
10122 char *kwnames[] = {
10123 (char *) "self",(char *) "mimetype", NULL
10124 };
10125
10126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10128 if (SWIG_arg_fail(1)) SWIG_fail;
10129 {
10130 arg2 = wxString_in_helper(obj1);
10131 if (arg2 == NULL) SWIG_fail;
10132 temp2 = true;
10133 }
10134 {
10135 PyThreadState* __tstate = wxPyBeginAllowThreads();
10136 (arg1)->SetMimeType((wxString const &)*arg2);
10137
10138 wxPyEndAllowThreads(__tstate);
10139 if (PyErr_Occurred()) SWIG_fail;
10140 }
10141 Py_INCREF(Py_None); resultobj = Py_None;
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return resultobj;
10147 fail:
10148 {
10149 if (temp2)
10150 delete arg2;
10151 }
10152 return NULL;
10153 }
10154
10155
10156 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10157 PyObject *obj;
10158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10159 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10160 Py_INCREF(obj);
10161 return Py_BuildValue((char *)"");
10162 }
10163 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj;
10165 wxImageHistogram *result;
10166 char *kwnames[] = {
10167 NULL
10168 };
10169
10170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10171 {
10172 PyThreadState* __tstate = wxPyBeginAllowThreads();
10173 result = (wxImageHistogram *)new wxImageHistogram();
10174
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10179 return resultobj;
10180 fail:
10181 return NULL;
10182 }
10183
10184
10185 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10186 PyObject *resultobj;
10187 unsigned char arg1 ;
10188 unsigned char arg2 ;
10189 unsigned char arg3 ;
10190 unsigned long result;
10191 PyObject * obj0 = 0 ;
10192 PyObject * obj1 = 0 ;
10193 PyObject * obj2 = 0 ;
10194 char *kwnames[] = {
10195 (char *) "r",(char *) "g",(char *) "b", NULL
10196 };
10197
10198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10199 {
10200 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10201 if (SWIG_arg_fail(1)) SWIG_fail;
10202 }
10203 {
10204 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10205 if (SWIG_arg_fail(2)) SWIG_fail;
10206 }
10207 {
10208 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10209 if (SWIG_arg_fail(3)) SWIG_fail;
10210 }
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10214
10215 wxPyEndAllowThreads(__tstate);
10216 if (PyErr_Occurred()) SWIG_fail;
10217 }
10218 {
10219 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10220 }
10221 return resultobj;
10222 fail:
10223 return NULL;
10224 }
10225
10226
10227 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj;
10229 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10230 unsigned char *arg2 = (unsigned char *) 0 ;
10231 unsigned char *arg3 = (unsigned char *) 0 ;
10232 unsigned char *arg4 = (unsigned char *) 0 ;
10233 unsigned char arg5 = (unsigned char) 1 ;
10234 unsigned char arg6 = (unsigned char) 0 ;
10235 unsigned char arg7 = (unsigned char) 0 ;
10236 bool result;
10237 unsigned char temp2 ;
10238 int res2 = 0 ;
10239 unsigned char temp3 ;
10240 int res3 = 0 ;
10241 unsigned char temp4 ;
10242 int res4 = 0 ;
10243 PyObject * obj0 = 0 ;
10244 PyObject * obj1 = 0 ;
10245 PyObject * obj2 = 0 ;
10246 PyObject * obj3 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10249 };
10250
10251 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10252 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10253 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10256 if (SWIG_arg_fail(1)) SWIG_fail;
10257 if (obj1) {
10258 {
10259 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10260 if (SWIG_arg_fail(5)) SWIG_fail;
10261 }
10262 }
10263 if (obj2) {
10264 {
10265 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10266 if (SWIG_arg_fail(6)) SWIG_fail;
10267 }
10268 }
10269 if (obj3) {
10270 {
10271 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10272 if (SWIG_arg_fail(7)) SWIG_fail;
10273 }
10274 }
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10278
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 {
10283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10284 }
10285 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10286 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10287 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10288 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10289 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10290 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10291 return resultobj;
10292 fail:
10293 return NULL;
10294 }
10295
10296
10297 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10298 PyObject *obj;
10299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10300 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10301 Py_INCREF(obj);
10302 return Py_BuildValue((char *)"");
10303 }
10304 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10305 PyObject *resultobj;
10306 wxString *arg1 = 0 ;
10307 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10308 int arg3 = (int) -1 ;
10309 wxImage *result;
10310 bool temp1 = false ;
10311 PyObject * obj0 = 0 ;
10312 PyObject * obj1 = 0 ;
10313 PyObject * obj2 = 0 ;
10314 char *kwnames[] = {
10315 (char *) "name",(char *) "type",(char *) "index", NULL
10316 };
10317
10318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10319 {
10320 arg1 = wxString_in_helper(obj0);
10321 if (arg1 == NULL) SWIG_fail;
10322 temp1 = true;
10323 }
10324 if (obj1) {
10325 {
10326 arg2 = (long)(SWIG_As_long(obj1));
10327 if (SWIG_arg_fail(2)) SWIG_fail;
10328 }
10329 }
10330 if (obj2) {
10331 {
10332 arg3 = (int)(SWIG_As_int(obj2));
10333 if (SWIG_arg_fail(3)) SWIG_fail;
10334 }
10335 }
10336 {
10337 PyThreadState* __tstate = wxPyBeginAllowThreads();
10338 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10339
10340 wxPyEndAllowThreads(__tstate);
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10344 {
10345 if (temp1)
10346 delete arg1;
10347 }
10348 return resultobj;
10349 fail:
10350 {
10351 if (temp1)
10352 delete arg1;
10353 }
10354 return NULL;
10355 }
10356
10357
10358 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj;
10360 wxImage *arg1 = (wxImage *) 0 ;
10361 PyObject * obj0 = 0 ;
10362 char *kwnames[] = {
10363 (char *) "self", NULL
10364 };
10365
10366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10368 if (SWIG_arg_fail(1)) SWIG_fail;
10369 {
10370 PyThreadState* __tstate = wxPyBeginAllowThreads();
10371 delete arg1;
10372
10373 wxPyEndAllowThreads(__tstate);
10374 if (PyErr_Occurred()) SWIG_fail;
10375 }
10376 Py_INCREF(Py_None); resultobj = Py_None;
10377 return resultobj;
10378 fail:
10379 return NULL;
10380 }
10381
10382
10383 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10384 PyObject *resultobj;
10385 wxString *arg1 = 0 ;
10386 wxString *arg2 = 0 ;
10387 int arg3 = (int) -1 ;
10388 wxImage *result;
10389 bool temp1 = false ;
10390 bool temp2 = false ;
10391 PyObject * obj0 = 0 ;
10392 PyObject * obj1 = 0 ;
10393 PyObject * obj2 = 0 ;
10394 char *kwnames[] = {
10395 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10396 };
10397
10398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10399 {
10400 arg1 = wxString_in_helper(obj0);
10401 if (arg1 == NULL) SWIG_fail;
10402 temp1 = true;
10403 }
10404 {
10405 arg2 = wxString_in_helper(obj1);
10406 if (arg2 == NULL) SWIG_fail;
10407 temp2 = true;
10408 }
10409 if (obj2) {
10410 {
10411 arg3 = (int)(SWIG_As_int(obj2));
10412 if (SWIG_arg_fail(3)) SWIG_fail;
10413 }
10414 }
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10418
10419 wxPyEndAllowThreads(__tstate);
10420 if (PyErr_Occurred()) SWIG_fail;
10421 }
10422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10423 {
10424 if (temp1)
10425 delete arg1;
10426 }
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return resultobj;
10432 fail:
10433 {
10434 if (temp1)
10435 delete arg1;
10436 }
10437 {
10438 if (temp2)
10439 delete arg2;
10440 }
10441 return NULL;
10442 }
10443
10444
10445 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10446 PyObject *resultobj;
10447 wxInputStream *arg1 = 0 ;
10448 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10449 int arg3 = (int) -1 ;
10450 wxImage *result;
10451 wxPyInputStream *temp1 ;
10452 bool created1 ;
10453 PyObject * obj0 = 0 ;
10454 PyObject * obj1 = 0 ;
10455 PyObject * obj2 = 0 ;
10456 char *kwnames[] = {
10457 (char *) "stream",(char *) "type",(char *) "index", NULL
10458 };
10459
10460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10461 {
10462 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10463 arg1 = temp1->m_wxis;
10464 created1 = false;
10465 } else {
10466 PyErr_Clear(); // clear the failure of the wxPyConvert above
10467 arg1 = wxPyCBInputStream_create(obj0, false);
10468 if (arg1 == NULL) {
10469 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10470 SWIG_fail;
10471 }
10472 created1 = true;
10473 }
10474 }
10475 if (obj1) {
10476 {
10477 arg2 = (long)(SWIG_As_long(obj1));
10478 if (SWIG_arg_fail(2)) SWIG_fail;
10479 }
10480 }
10481 if (obj2) {
10482 {
10483 arg3 = (int)(SWIG_As_int(obj2));
10484 if (SWIG_arg_fail(3)) SWIG_fail;
10485 }
10486 }
10487 {
10488 PyThreadState* __tstate = wxPyBeginAllowThreads();
10489 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10490
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10495 {
10496 if (created1)
10497 delete arg1;
10498 }
10499 return resultobj;
10500 fail:
10501 {
10502 if (created1)
10503 delete arg1;
10504 }
10505 return NULL;
10506 }
10507
10508
10509 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10510 PyObject *resultobj;
10511 wxInputStream *arg1 = 0 ;
10512 wxString *arg2 = 0 ;
10513 int arg3 = (int) -1 ;
10514 wxImage *result;
10515 wxPyInputStream *temp1 ;
10516 bool created1 ;
10517 bool temp2 = false ;
10518 PyObject * obj0 = 0 ;
10519 PyObject * obj1 = 0 ;
10520 PyObject * obj2 = 0 ;
10521 char *kwnames[] = {
10522 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10523 };
10524
10525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10526 {
10527 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10528 arg1 = temp1->m_wxis;
10529 created1 = false;
10530 } else {
10531 PyErr_Clear(); // clear the failure of the wxPyConvert above
10532 arg1 = wxPyCBInputStream_create(obj0, false);
10533 if (arg1 == NULL) {
10534 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10535 SWIG_fail;
10536 }
10537 created1 = true;
10538 }
10539 }
10540 {
10541 arg2 = wxString_in_helper(obj1);
10542 if (arg2 == NULL) SWIG_fail;
10543 temp2 = true;
10544 }
10545 if (obj2) {
10546 {
10547 arg3 = (int)(SWIG_As_int(obj2));
10548 if (SWIG_arg_fail(3)) SWIG_fail;
10549 }
10550 }
10551 {
10552 PyThreadState* __tstate = wxPyBeginAllowThreads();
10553 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10554
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10559 {
10560 if (created1)
10561 delete arg1;
10562 }
10563 {
10564 if (temp2)
10565 delete arg2;
10566 }
10567 return resultobj;
10568 fail:
10569 {
10570 if (created1)
10571 delete arg1;
10572 }
10573 {
10574 if (temp2)
10575 delete arg2;
10576 }
10577 return NULL;
10578 }
10579
10580
10581 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10582 PyObject *resultobj;
10583 int arg1 = (int) 0 ;
10584 int arg2 = (int) 0 ;
10585 bool arg3 = (bool) true ;
10586 wxImage *result;
10587 PyObject * obj0 = 0 ;
10588 PyObject * obj1 = 0 ;
10589 PyObject * obj2 = 0 ;
10590 char *kwnames[] = {
10591 (char *) "width",(char *) "height",(char *) "clear", NULL
10592 };
10593
10594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10595 if (obj0) {
10596 {
10597 arg1 = (int)(SWIG_As_int(obj0));
10598 if (SWIG_arg_fail(1)) SWIG_fail;
10599 }
10600 }
10601 if (obj1) {
10602 {
10603 arg2 = (int)(SWIG_As_int(obj1));
10604 if (SWIG_arg_fail(2)) SWIG_fail;
10605 }
10606 }
10607 if (obj2) {
10608 {
10609 arg3 = (bool)(SWIG_As_bool(obj2));
10610 if (SWIG_arg_fail(3)) SWIG_fail;
10611 }
10612 }
10613 {
10614 PyThreadState* __tstate = wxPyBeginAllowThreads();
10615 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10616
10617 wxPyEndAllowThreads(__tstate);
10618 if (PyErr_Occurred()) SWIG_fail;
10619 }
10620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10621 return resultobj;
10622 fail:
10623 return NULL;
10624 }
10625
10626
10627 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10628 PyObject *resultobj;
10629 wxBitmap *arg1 = 0 ;
10630 wxImage *result;
10631 PyObject * obj0 = 0 ;
10632 char *kwnames[] = {
10633 (char *) "bitmap", NULL
10634 };
10635
10636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10637 {
10638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10639 if (SWIG_arg_fail(1)) SWIG_fail;
10640 if (arg1 == NULL) {
10641 SWIG_null_ref("wxBitmap");
10642 }
10643 if (SWIG_arg_fail(1)) SWIG_fail;
10644 }
10645 {
10646 if (!wxPyCheckForApp()) SWIG_fail;
10647 PyThreadState* __tstate = wxPyBeginAllowThreads();
10648 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10649
10650 wxPyEndAllowThreads(__tstate);
10651 if (PyErr_Occurred()) SWIG_fail;
10652 }
10653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10654 return resultobj;
10655 fail:
10656 return NULL;
10657 }
10658
10659
10660 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj;
10662 int arg1 ;
10663 int arg2 ;
10664 unsigned char *arg3 = (unsigned char *) 0 ;
10665 wxImage *result;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 PyObject * obj2 = 0 ;
10669 char *kwnames[] = {
10670 (char *) "width",(char *) "height",(char *) "data", NULL
10671 };
10672
10673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10674 {
10675 arg1 = (int)(SWIG_As_int(obj0));
10676 if (SWIG_arg_fail(1)) SWIG_fail;
10677 }
10678 {
10679 arg2 = (int)(SWIG_As_int(obj1));
10680 if (SWIG_arg_fail(2)) SWIG_fail;
10681 }
10682 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10683 if (SWIG_arg_fail(3)) SWIG_fail;
10684 {
10685 PyThreadState* __tstate = wxPyBeginAllowThreads();
10686 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10687
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj;
10700 int arg1 ;
10701 int arg2 ;
10702 unsigned char *arg3 = (unsigned char *) 0 ;
10703 unsigned char *arg4 = (unsigned char *) 0 ;
10704 wxImage *result;
10705 PyObject * obj0 = 0 ;
10706 PyObject * obj1 = 0 ;
10707 PyObject * obj2 = 0 ;
10708 PyObject * obj3 = 0 ;
10709 char *kwnames[] = {
10710 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10711 };
10712
10713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10714 {
10715 arg1 = (int)(SWIG_As_int(obj0));
10716 if (SWIG_arg_fail(1)) SWIG_fail;
10717 }
10718 {
10719 arg2 = (int)(SWIG_As_int(obj1));
10720 if (SWIG_arg_fail(2)) SWIG_fail;
10721 }
10722 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10723 if (SWIG_arg_fail(3)) SWIG_fail;
10724 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10725 if (SWIG_arg_fail(4)) SWIG_fail;
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10729
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10741 PyObject *resultobj;
10742 wxImage *arg1 = (wxImage *) 0 ;
10743 int arg2 ;
10744 int arg3 ;
10745 PyObject * obj0 = 0 ;
10746 PyObject * obj1 = 0 ;
10747 PyObject * obj2 = 0 ;
10748 char *kwnames[] = {
10749 (char *) "self",(char *) "width",(char *) "height", NULL
10750 };
10751
10752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10754 if (SWIG_arg_fail(1)) SWIG_fail;
10755 {
10756 arg2 = (int)(SWIG_As_int(obj1));
10757 if (SWIG_arg_fail(2)) SWIG_fail;
10758 }
10759 {
10760 arg3 = (int)(SWIG_As_int(obj2));
10761 if (SWIG_arg_fail(3)) SWIG_fail;
10762 }
10763 {
10764 PyThreadState* __tstate = wxPyBeginAllowThreads();
10765 (arg1)->Create(arg2,arg3);
10766
10767 wxPyEndAllowThreads(__tstate);
10768 if (PyErr_Occurred()) SWIG_fail;
10769 }
10770 Py_INCREF(Py_None); resultobj = Py_None;
10771 return resultobj;
10772 fail:
10773 return NULL;
10774 }
10775
10776
10777 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10778 PyObject *resultobj;
10779 wxImage *arg1 = (wxImage *) 0 ;
10780 PyObject * obj0 = 0 ;
10781 char *kwnames[] = {
10782 (char *) "self", NULL
10783 };
10784
10785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10787 if (SWIG_arg_fail(1)) SWIG_fail;
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 (arg1)->Destroy();
10791
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 Py_INCREF(Py_None); resultobj = Py_None;
10796 return resultobj;
10797 fail:
10798 return NULL;
10799 }
10800
10801
10802 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10803 PyObject *resultobj;
10804 wxImage *arg1 = (wxImage *) 0 ;
10805 int arg2 ;
10806 int arg3 ;
10807 SwigValueWrapper<wxImage > result;
10808 PyObject * obj0 = 0 ;
10809 PyObject * obj1 = 0 ;
10810 PyObject * obj2 = 0 ;
10811 char *kwnames[] = {
10812 (char *) "self",(char *) "width",(char *) "height", NULL
10813 };
10814
10815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10817 if (SWIG_arg_fail(1)) SWIG_fail;
10818 {
10819 arg2 = (int)(SWIG_As_int(obj1));
10820 if (SWIG_arg_fail(2)) SWIG_fail;
10821 }
10822 {
10823 arg3 = (int)(SWIG_As_int(obj2));
10824 if (SWIG_arg_fail(3)) SWIG_fail;
10825 }
10826 {
10827 PyThreadState* __tstate = wxPyBeginAllowThreads();
10828 result = (arg1)->Scale(arg2,arg3);
10829
10830 wxPyEndAllowThreads(__tstate);
10831 if (PyErr_Occurred()) SWIG_fail;
10832 }
10833 {
10834 wxImage * resultptr;
10835 resultptr = new wxImage((wxImage &)(result));
10836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10837 }
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10845 PyObject *resultobj;
10846 wxImage *arg1 = (wxImage *) 0 ;
10847 int arg2 ;
10848 int arg3 ;
10849 SwigValueWrapper<wxImage > result;
10850 PyObject * obj0 = 0 ;
10851 PyObject * obj1 = 0 ;
10852 PyObject * obj2 = 0 ;
10853 char *kwnames[] = {
10854 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10855 };
10856
10857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10859 if (SWIG_arg_fail(1)) SWIG_fail;
10860 {
10861 arg2 = (int)(SWIG_As_int(obj1));
10862 if (SWIG_arg_fail(2)) SWIG_fail;
10863 }
10864 {
10865 arg3 = (int)(SWIG_As_int(obj2));
10866 if (SWIG_arg_fail(3)) SWIG_fail;
10867 }
10868 {
10869 PyThreadState* __tstate = wxPyBeginAllowThreads();
10870 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10871
10872 wxPyEndAllowThreads(__tstate);
10873 if (PyErr_Occurred()) SWIG_fail;
10874 }
10875 {
10876 wxImage * resultptr;
10877 resultptr = new wxImage((wxImage &)(result));
10878 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10879 }
10880 return resultobj;
10881 fail:
10882 return NULL;
10883 }
10884
10885
10886 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10887 PyObject *resultobj;
10888 wxImage *arg1 = (wxImage *) 0 ;
10889 int arg2 ;
10890 int arg3 ;
10891 wxImage *result;
10892 PyObject * obj0 = 0 ;
10893 PyObject * obj1 = 0 ;
10894 PyObject * obj2 = 0 ;
10895 char *kwnames[] = {
10896 (char *) "self",(char *) "width",(char *) "height", NULL
10897 };
10898
10899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10901 if (SWIG_arg_fail(1)) SWIG_fail;
10902 {
10903 arg2 = (int)(SWIG_As_int(obj1));
10904 if (SWIG_arg_fail(2)) SWIG_fail;
10905 }
10906 {
10907 arg3 = (int)(SWIG_As_int(obj2));
10908 if (SWIG_arg_fail(3)) SWIG_fail;
10909 }
10910 {
10911 PyThreadState* __tstate = wxPyBeginAllowThreads();
10912 {
10913 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10914 result = (wxImage *) &_result_ref;
10915 }
10916
10917 wxPyEndAllowThreads(__tstate);
10918 if (PyErr_Occurred()) SWIG_fail;
10919 }
10920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10921 return resultobj;
10922 fail:
10923 return NULL;
10924 }
10925
10926
10927 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10928 PyObject *resultobj;
10929 wxImage *arg1 = (wxImage *) 0 ;
10930 int arg2 ;
10931 int arg3 ;
10932 unsigned char arg4 ;
10933 unsigned char arg5 ;
10934 unsigned char arg6 ;
10935 PyObject * obj0 = 0 ;
10936 PyObject * obj1 = 0 ;
10937 PyObject * obj2 = 0 ;
10938 PyObject * obj3 = 0 ;
10939 PyObject * obj4 = 0 ;
10940 PyObject * obj5 = 0 ;
10941 char *kwnames[] = {
10942 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10943 };
10944
10945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10947 if (SWIG_arg_fail(1)) SWIG_fail;
10948 {
10949 arg2 = (int)(SWIG_As_int(obj1));
10950 if (SWIG_arg_fail(2)) SWIG_fail;
10951 }
10952 {
10953 arg3 = (int)(SWIG_As_int(obj2));
10954 if (SWIG_arg_fail(3)) SWIG_fail;
10955 }
10956 {
10957 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10958 if (SWIG_arg_fail(4)) SWIG_fail;
10959 }
10960 {
10961 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10962 if (SWIG_arg_fail(5)) SWIG_fail;
10963 }
10964 {
10965 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10966 if (SWIG_arg_fail(6)) SWIG_fail;
10967 }
10968 {
10969 PyThreadState* __tstate = wxPyBeginAllowThreads();
10970 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10971
10972 wxPyEndAllowThreads(__tstate);
10973 if (PyErr_Occurred()) SWIG_fail;
10974 }
10975 Py_INCREF(Py_None); resultobj = Py_None;
10976 return resultobj;
10977 fail:
10978 return NULL;
10979 }
10980
10981
10982 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10983 PyObject *resultobj;
10984 wxImage *arg1 = (wxImage *) 0 ;
10985 int arg2 ;
10986 int arg3 ;
10987 unsigned char result;
10988 PyObject * obj0 = 0 ;
10989 PyObject * obj1 = 0 ;
10990 PyObject * obj2 = 0 ;
10991 char *kwnames[] = {
10992 (char *) "self",(char *) "x",(char *) "y", NULL
10993 };
10994
10995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10997 if (SWIG_arg_fail(1)) SWIG_fail;
10998 {
10999 arg2 = (int)(SWIG_As_int(obj1));
11000 if (SWIG_arg_fail(2)) SWIG_fail;
11001 }
11002 {
11003 arg3 = (int)(SWIG_As_int(obj2));
11004 if (SWIG_arg_fail(3)) SWIG_fail;
11005 }
11006 {
11007 PyThreadState* __tstate = wxPyBeginAllowThreads();
11008 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11009
11010 wxPyEndAllowThreads(__tstate);
11011 if (PyErr_Occurred()) SWIG_fail;
11012 }
11013 {
11014 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11015 }
11016 return resultobj;
11017 fail:
11018 return NULL;
11019 }
11020
11021
11022 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11023 PyObject *resultobj;
11024 wxImage *arg1 = (wxImage *) 0 ;
11025 int arg2 ;
11026 int arg3 ;
11027 unsigned char result;
11028 PyObject * obj0 = 0 ;
11029 PyObject * obj1 = 0 ;
11030 PyObject * obj2 = 0 ;
11031 char *kwnames[] = {
11032 (char *) "self",(char *) "x",(char *) "y", NULL
11033 };
11034
11035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11037 if (SWIG_arg_fail(1)) SWIG_fail;
11038 {
11039 arg2 = (int)(SWIG_As_int(obj1));
11040 if (SWIG_arg_fail(2)) SWIG_fail;
11041 }
11042 {
11043 arg3 = (int)(SWIG_As_int(obj2));
11044 if (SWIG_arg_fail(3)) SWIG_fail;
11045 }
11046 {
11047 PyThreadState* __tstate = wxPyBeginAllowThreads();
11048 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11049
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 {
11054 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11055 }
11056 return resultobj;
11057 fail:
11058 return NULL;
11059 }
11060
11061
11062 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11063 PyObject *resultobj;
11064 wxImage *arg1 = (wxImage *) 0 ;
11065 int arg2 ;
11066 int arg3 ;
11067 unsigned char result;
11068 PyObject * obj0 = 0 ;
11069 PyObject * obj1 = 0 ;
11070 PyObject * obj2 = 0 ;
11071 char *kwnames[] = {
11072 (char *) "self",(char *) "x",(char *) "y", NULL
11073 };
11074
11075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11077 if (SWIG_arg_fail(1)) SWIG_fail;
11078 {
11079 arg2 = (int)(SWIG_As_int(obj1));
11080 if (SWIG_arg_fail(2)) SWIG_fail;
11081 }
11082 {
11083 arg3 = (int)(SWIG_As_int(obj2));
11084 if (SWIG_arg_fail(3)) SWIG_fail;
11085 }
11086 {
11087 PyThreadState* __tstate = wxPyBeginAllowThreads();
11088 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11089
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 {
11094 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11095 }
11096 return resultobj;
11097 fail:
11098 return NULL;
11099 }
11100
11101
11102 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11103 PyObject *resultobj;
11104 wxImage *arg1 = (wxImage *) 0 ;
11105 int arg2 ;
11106 int arg3 ;
11107 unsigned char arg4 ;
11108 PyObject * obj0 = 0 ;
11109 PyObject * obj1 = 0 ;
11110 PyObject * obj2 = 0 ;
11111 PyObject * obj3 = 0 ;
11112 char *kwnames[] = {
11113 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11114 };
11115
11116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11118 if (SWIG_arg_fail(1)) SWIG_fail;
11119 {
11120 arg2 = (int)(SWIG_As_int(obj1));
11121 if (SWIG_arg_fail(2)) SWIG_fail;
11122 }
11123 {
11124 arg3 = (int)(SWIG_As_int(obj2));
11125 if (SWIG_arg_fail(3)) SWIG_fail;
11126 }
11127 {
11128 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11129 if (SWIG_arg_fail(4)) SWIG_fail;
11130 }
11131 {
11132 PyThreadState* __tstate = wxPyBeginAllowThreads();
11133 (arg1)->SetAlpha(arg2,arg3,arg4);
11134
11135 wxPyEndAllowThreads(__tstate);
11136 if (PyErr_Occurred()) SWIG_fail;
11137 }
11138 Py_INCREF(Py_None); resultobj = Py_None;
11139 return resultobj;
11140 fail:
11141 return NULL;
11142 }
11143
11144
11145 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11146 PyObject *resultobj;
11147 wxImage *arg1 = (wxImage *) 0 ;
11148 int arg2 ;
11149 int arg3 ;
11150 unsigned char result;
11151 PyObject * obj0 = 0 ;
11152 PyObject * obj1 = 0 ;
11153 PyObject * obj2 = 0 ;
11154 char *kwnames[] = {
11155 (char *) "self",(char *) "x",(char *) "y", NULL
11156 };
11157
11158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11160 if (SWIG_arg_fail(1)) SWIG_fail;
11161 {
11162 arg2 = (int)(SWIG_As_int(obj1));
11163 if (SWIG_arg_fail(2)) SWIG_fail;
11164 }
11165 {
11166 arg3 = (int)(SWIG_As_int(obj2));
11167 if (SWIG_arg_fail(3)) SWIG_fail;
11168 }
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11172
11173 wxPyEndAllowThreads(__tstate);
11174 if (PyErr_Occurred()) SWIG_fail;
11175 }
11176 {
11177 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11178 }
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11186 PyObject *resultobj;
11187 wxImage *arg1 = (wxImage *) 0 ;
11188 bool result;
11189 PyObject * obj0 = 0 ;
11190 char *kwnames[] = {
11191 (char *) "self", NULL
11192 };
11193
11194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11196 if (SWIG_arg_fail(1)) SWIG_fail;
11197 {
11198 PyThreadState* __tstate = wxPyBeginAllowThreads();
11199 result = (bool)(arg1)->HasAlpha();
11200
11201 wxPyEndAllowThreads(__tstate);
11202 if (PyErr_Occurred()) SWIG_fail;
11203 }
11204 {
11205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11206 }
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj;
11215 wxImage *arg1 = (wxImage *) 0 ;
11216 PyObject * obj0 = 0 ;
11217 char *kwnames[] = {
11218 (char *) "self", NULL
11219 };
11220
11221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11223 if (SWIG_arg_fail(1)) SWIG_fail;
11224 {
11225 PyThreadState* __tstate = wxPyBeginAllowThreads();
11226 (arg1)->InitAlpha();
11227
11228 wxPyEndAllowThreads(__tstate);
11229 if (PyErr_Occurred()) SWIG_fail;
11230 }
11231 Py_INCREF(Py_None); resultobj = Py_None;
11232 return resultobj;
11233 fail:
11234 return NULL;
11235 }
11236
11237
11238 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11239 PyObject *resultobj;
11240 wxImage *arg1 = (wxImage *) 0 ;
11241 byte *arg2 = (byte *) 0 ;
11242 byte *arg3 = (byte *) 0 ;
11243 byte *arg4 = (byte *) 0 ;
11244 byte arg5 = (byte) 0 ;
11245 byte arg6 = (byte) 0 ;
11246 byte arg7 = (byte) 0 ;
11247 bool result;
11248 byte temp2 ;
11249 int res2 = 0 ;
11250 byte temp3 ;
11251 int res3 = 0 ;
11252 byte temp4 ;
11253 int res4 = 0 ;
11254 PyObject * obj0 = 0 ;
11255 PyObject * obj1 = 0 ;
11256 PyObject * obj2 = 0 ;
11257 PyObject * obj3 = 0 ;
11258 char *kwnames[] = {
11259 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11260 };
11261
11262 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11263 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11264 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11267 if (SWIG_arg_fail(1)) SWIG_fail;
11268 if (obj1) {
11269 {
11270 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11271 if (SWIG_arg_fail(5)) SWIG_fail;
11272 }
11273 }
11274 if (obj2) {
11275 {
11276 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11277 if (SWIG_arg_fail(6)) SWIG_fail;
11278 }
11279 }
11280 if (obj3) {
11281 {
11282 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11283 if (SWIG_arg_fail(7)) SWIG_fail;
11284 }
11285 }
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11289
11290 wxPyEndAllowThreads(__tstate);
11291 if (PyErr_Occurred()) SWIG_fail;
11292 }
11293 {
11294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11295 }
11296 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11297 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11298 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11299 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11300 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11301 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11302 return resultobj;
11303 fail:
11304 return NULL;
11305 }
11306
11307
11308 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11309 PyObject *resultobj;
11310 wxImage *arg1 = (wxImage *) 0 ;
11311 byte arg2 = (byte) 128 ;
11312 bool result;
11313 PyObject * obj0 = 0 ;
11314 PyObject * obj1 = 0 ;
11315 char *kwnames[] = {
11316 (char *) "self",(char *) "threshold", NULL
11317 };
11318
11319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11321 if (SWIG_arg_fail(1)) SWIG_fail;
11322 if (obj1) {
11323 {
11324 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11325 if (SWIG_arg_fail(2)) SWIG_fail;
11326 }
11327 }
11328 {
11329 PyThreadState* __tstate = wxPyBeginAllowThreads();
11330 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11331
11332 wxPyEndAllowThreads(__tstate);
11333 if (PyErr_Occurred()) SWIG_fail;
11334 }
11335 {
11336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11337 }
11338 return resultobj;
11339 fail:
11340 return NULL;
11341 }
11342
11343
11344 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11345 PyObject *resultobj;
11346 wxImage *arg1 = (wxImage *) 0 ;
11347 unsigned char arg2 ;
11348 unsigned char arg3 ;
11349 unsigned char arg4 ;
11350 bool result;
11351 PyObject * obj0 = 0 ;
11352 PyObject * obj1 = 0 ;
11353 PyObject * obj2 = 0 ;
11354 PyObject * obj3 = 0 ;
11355 char *kwnames[] = {
11356 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11357 };
11358
11359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11361 if (SWIG_arg_fail(1)) SWIG_fail;
11362 {
11363 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11364 if (SWIG_arg_fail(2)) SWIG_fail;
11365 }
11366 {
11367 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11368 if (SWIG_arg_fail(3)) SWIG_fail;
11369 }
11370 {
11371 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11372 if (SWIG_arg_fail(4)) SWIG_fail;
11373 }
11374 {
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11377
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 {
11382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11383 }
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj;
11392 wxImage *arg1 = (wxImage *) 0 ;
11393 wxImage *arg2 = 0 ;
11394 byte arg3 ;
11395 byte arg4 ;
11396 byte arg5 ;
11397 bool result;
11398 PyObject * obj0 = 0 ;
11399 PyObject * obj1 = 0 ;
11400 PyObject * obj2 = 0 ;
11401 PyObject * obj3 = 0 ;
11402 PyObject * obj4 = 0 ;
11403 char *kwnames[] = {
11404 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11405 };
11406
11407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11409 if (SWIG_arg_fail(1)) SWIG_fail;
11410 {
11411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11412 if (SWIG_arg_fail(2)) SWIG_fail;
11413 if (arg2 == NULL) {
11414 SWIG_null_ref("wxImage");
11415 }
11416 if (SWIG_arg_fail(2)) SWIG_fail;
11417 }
11418 {
11419 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11420 if (SWIG_arg_fail(3)) SWIG_fail;
11421 }
11422 {
11423 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11424 if (SWIG_arg_fail(4)) SWIG_fail;
11425 }
11426 {
11427 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11428 if (SWIG_arg_fail(5)) SWIG_fail;
11429 }
11430 {
11431 PyThreadState* __tstate = wxPyBeginAllowThreads();
11432 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11433
11434 wxPyEndAllowThreads(__tstate);
11435 if (PyErr_Occurred()) SWIG_fail;
11436 }
11437 {
11438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11439 }
11440 return resultobj;
11441 fail:
11442 return NULL;
11443 }
11444
11445
11446 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11447 PyObject *resultobj;
11448 wxString *arg1 = 0 ;
11449 bool result;
11450 bool temp1 = false ;
11451 PyObject * obj0 = 0 ;
11452 char *kwnames[] = {
11453 (char *) "name", NULL
11454 };
11455
11456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11457 {
11458 arg1 = wxString_in_helper(obj0);
11459 if (arg1 == NULL) SWIG_fail;
11460 temp1 = true;
11461 }
11462 {
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11465
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 {
11470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11471 }
11472 {
11473 if (temp1)
11474 delete arg1;
11475 }
11476 return resultobj;
11477 fail:
11478 {
11479 if (temp1)
11480 delete arg1;
11481 }
11482 return NULL;
11483 }
11484
11485
11486 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11487 PyObject *resultobj;
11488 wxString *arg1 = 0 ;
11489 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11490 int result;
11491 bool temp1 = false ;
11492 PyObject * obj0 = 0 ;
11493 PyObject * obj1 = 0 ;
11494 char *kwnames[] = {
11495 (char *) "name",(char *) "type", NULL
11496 };
11497
11498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11499 {
11500 arg1 = wxString_in_helper(obj0);
11501 if (arg1 == NULL) SWIG_fail;
11502 temp1 = true;
11503 }
11504 if (obj1) {
11505 {
11506 arg2 = (long)(SWIG_As_long(obj1));
11507 if (SWIG_arg_fail(2)) SWIG_fail;
11508 }
11509 }
11510 {
11511 PyThreadState* __tstate = wxPyBeginAllowThreads();
11512 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11513
11514 wxPyEndAllowThreads(__tstate);
11515 if (PyErr_Occurred()) SWIG_fail;
11516 }
11517 {
11518 resultobj = SWIG_From_int((int)(result));
11519 }
11520 {
11521 if (temp1)
11522 delete arg1;
11523 }
11524 return resultobj;
11525 fail:
11526 {
11527 if (temp1)
11528 delete arg1;
11529 }
11530 return NULL;
11531 }
11532
11533
11534 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11535 PyObject *resultobj;
11536 wxImage *arg1 = (wxImage *) 0 ;
11537 wxString *arg2 = 0 ;
11538 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11539 int arg4 = (int) -1 ;
11540 bool result;
11541 bool temp2 = false ;
11542 PyObject * obj0 = 0 ;
11543 PyObject * obj1 = 0 ;
11544 PyObject * obj2 = 0 ;
11545 PyObject * obj3 = 0 ;
11546 char *kwnames[] = {
11547 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11548 };
11549
11550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11552 if (SWIG_arg_fail(1)) SWIG_fail;
11553 {
11554 arg2 = wxString_in_helper(obj1);
11555 if (arg2 == NULL) SWIG_fail;
11556 temp2 = true;
11557 }
11558 if (obj2) {
11559 {
11560 arg3 = (long)(SWIG_As_long(obj2));
11561 if (SWIG_arg_fail(3)) SWIG_fail;
11562 }
11563 }
11564 if (obj3) {
11565 {
11566 arg4 = (int)(SWIG_As_int(obj3));
11567 if (SWIG_arg_fail(4)) SWIG_fail;
11568 }
11569 }
11570 {
11571 PyThreadState* __tstate = wxPyBeginAllowThreads();
11572 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11573
11574 wxPyEndAllowThreads(__tstate);
11575 if (PyErr_Occurred()) SWIG_fail;
11576 }
11577 {
11578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11579 }
11580 {
11581 if (temp2)
11582 delete arg2;
11583 }
11584 return resultobj;
11585 fail:
11586 {
11587 if (temp2)
11588 delete arg2;
11589 }
11590 return NULL;
11591 }
11592
11593
11594 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11595 PyObject *resultobj;
11596 wxImage *arg1 = (wxImage *) 0 ;
11597 wxString *arg2 = 0 ;
11598 wxString *arg3 = 0 ;
11599 int arg4 = (int) -1 ;
11600 bool result;
11601 bool temp2 = false ;
11602 bool temp3 = false ;
11603 PyObject * obj0 = 0 ;
11604 PyObject * obj1 = 0 ;
11605 PyObject * obj2 = 0 ;
11606 PyObject * obj3 = 0 ;
11607 char *kwnames[] = {
11608 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11609 };
11610
11611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11613 if (SWIG_arg_fail(1)) SWIG_fail;
11614 {
11615 arg2 = wxString_in_helper(obj1);
11616 if (arg2 == NULL) SWIG_fail;
11617 temp2 = true;
11618 }
11619 {
11620 arg3 = wxString_in_helper(obj2);
11621 if (arg3 == NULL) SWIG_fail;
11622 temp3 = true;
11623 }
11624 if (obj3) {
11625 {
11626 arg4 = (int)(SWIG_As_int(obj3));
11627 if (SWIG_arg_fail(4)) SWIG_fail;
11628 }
11629 }
11630 {
11631 PyThreadState* __tstate = wxPyBeginAllowThreads();
11632 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11633
11634 wxPyEndAllowThreads(__tstate);
11635 if (PyErr_Occurred()) SWIG_fail;
11636 }
11637 {
11638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11639 }
11640 {
11641 if (temp2)
11642 delete arg2;
11643 }
11644 {
11645 if (temp3)
11646 delete arg3;
11647 }
11648 return resultobj;
11649 fail:
11650 {
11651 if (temp2)
11652 delete arg2;
11653 }
11654 {
11655 if (temp3)
11656 delete arg3;
11657 }
11658 return NULL;
11659 }
11660
11661
11662 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11663 PyObject *resultobj;
11664 wxImage *arg1 = (wxImage *) 0 ;
11665 wxString *arg2 = 0 ;
11666 int arg3 ;
11667 bool result;
11668 bool temp2 = false ;
11669 PyObject * obj0 = 0 ;
11670 PyObject * obj1 = 0 ;
11671 PyObject * obj2 = 0 ;
11672 char *kwnames[] = {
11673 (char *) "self",(char *) "name",(char *) "type", NULL
11674 };
11675
11676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11678 if (SWIG_arg_fail(1)) SWIG_fail;
11679 {
11680 arg2 = wxString_in_helper(obj1);
11681 if (arg2 == NULL) SWIG_fail;
11682 temp2 = true;
11683 }
11684 {
11685 arg3 = (int)(SWIG_As_int(obj2));
11686 if (SWIG_arg_fail(3)) SWIG_fail;
11687 }
11688 {
11689 PyThreadState* __tstate = wxPyBeginAllowThreads();
11690 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11691
11692 wxPyEndAllowThreads(__tstate);
11693 if (PyErr_Occurred()) SWIG_fail;
11694 }
11695 {
11696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11697 }
11698 {
11699 if (temp2)
11700 delete arg2;
11701 }
11702 return resultobj;
11703 fail:
11704 {
11705 if (temp2)
11706 delete arg2;
11707 }
11708 return NULL;
11709 }
11710
11711
11712 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11713 PyObject *resultobj;
11714 wxImage *arg1 = (wxImage *) 0 ;
11715 wxString *arg2 = 0 ;
11716 wxString *arg3 = 0 ;
11717 bool result;
11718 bool temp2 = false ;
11719 bool temp3 = false ;
11720 PyObject * obj0 = 0 ;
11721 PyObject * obj1 = 0 ;
11722 PyObject * obj2 = 0 ;
11723 char *kwnames[] = {
11724 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11725 };
11726
11727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11729 if (SWIG_arg_fail(1)) SWIG_fail;
11730 {
11731 arg2 = wxString_in_helper(obj1);
11732 if (arg2 == NULL) SWIG_fail;
11733 temp2 = true;
11734 }
11735 {
11736 arg3 = wxString_in_helper(obj2);
11737 if (arg3 == NULL) SWIG_fail;
11738 temp3 = true;
11739 }
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11743
11744 wxPyEndAllowThreads(__tstate);
11745 if (PyErr_Occurred()) SWIG_fail;
11746 }
11747 {
11748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11749 }
11750 {
11751 if (temp2)
11752 delete arg2;
11753 }
11754 {
11755 if (temp3)
11756 delete arg3;
11757 }
11758 return resultobj;
11759 fail:
11760 {
11761 if (temp2)
11762 delete arg2;
11763 }
11764 {
11765 if (temp3)
11766 delete arg3;
11767 }
11768 return NULL;
11769 }
11770
11771
11772 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11773 PyObject *resultobj;
11774 wxInputStream *arg1 = 0 ;
11775 bool result;
11776 wxPyInputStream *temp1 ;
11777 bool created1 ;
11778 PyObject * obj0 = 0 ;
11779 char *kwnames[] = {
11780 (char *) "stream", NULL
11781 };
11782
11783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11784 {
11785 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11786 arg1 = temp1->m_wxis;
11787 created1 = false;
11788 } else {
11789 PyErr_Clear(); // clear the failure of the wxPyConvert above
11790 arg1 = wxPyCBInputStream_create(obj0, false);
11791 if (arg1 == NULL) {
11792 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11793 SWIG_fail;
11794 }
11795 created1 = true;
11796 }
11797 }
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = (bool)wxImage::CanRead(*arg1);
11801
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 {
11806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11807 }
11808 {
11809 if (created1)
11810 delete arg1;
11811 }
11812 return resultobj;
11813 fail:
11814 {
11815 if (created1)
11816 delete arg1;
11817 }
11818 return NULL;
11819 }
11820
11821
11822 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11823 PyObject *resultobj;
11824 wxImage *arg1 = (wxImage *) 0 ;
11825 wxInputStream *arg2 = 0 ;
11826 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11827 int arg4 = (int) -1 ;
11828 bool result;
11829 wxPyInputStream *temp2 ;
11830 bool created2 ;
11831 PyObject * obj0 = 0 ;
11832 PyObject * obj1 = 0 ;
11833 PyObject * obj2 = 0 ;
11834 PyObject * obj3 = 0 ;
11835 char *kwnames[] = {
11836 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11837 };
11838
11839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11841 if (SWIG_arg_fail(1)) SWIG_fail;
11842 {
11843 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11844 arg2 = temp2->m_wxis;
11845 created2 = false;
11846 } else {
11847 PyErr_Clear(); // clear the failure of the wxPyConvert above
11848 arg2 = wxPyCBInputStream_create(obj1, false);
11849 if (arg2 == NULL) {
11850 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11851 SWIG_fail;
11852 }
11853 created2 = true;
11854 }
11855 }
11856 if (obj2) {
11857 {
11858 arg3 = (long)(SWIG_As_long(obj2));
11859 if (SWIG_arg_fail(3)) SWIG_fail;
11860 }
11861 }
11862 if (obj3) {
11863 {
11864 arg4 = (int)(SWIG_As_int(obj3));
11865 if (SWIG_arg_fail(4)) SWIG_fail;
11866 }
11867 }
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11871
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11877 }
11878 {
11879 if (created2)
11880 delete arg2;
11881 }
11882 return resultobj;
11883 fail:
11884 {
11885 if (created2)
11886 delete arg2;
11887 }
11888 return NULL;
11889 }
11890
11891
11892 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11893 PyObject *resultobj;
11894 wxImage *arg1 = (wxImage *) 0 ;
11895 wxInputStream *arg2 = 0 ;
11896 wxString *arg3 = 0 ;
11897 int arg4 = (int) -1 ;
11898 bool result;
11899 wxPyInputStream *temp2 ;
11900 bool created2 ;
11901 bool temp3 = false ;
11902 PyObject * obj0 = 0 ;
11903 PyObject * obj1 = 0 ;
11904 PyObject * obj2 = 0 ;
11905 PyObject * obj3 = 0 ;
11906 char *kwnames[] = {
11907 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11908 };
11909
11910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11912 if (SWIG_arg_fail(1)) SWIG_fail;
11913 {
11914 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11915 arg2 = temp2->m_wxis;
11916 created2 = false;
11917 } else {
11918 PyErr_Clear(); // clear the failure of the wxPyConvert above
11919 arg2 = wxPyCBInputStream_create(obj1, false);
11920 if (arg2 == NULL) {
11921 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11922 SWIG_fail;
11923 }
11924 created2 = true;
11925 }
11926 }
11927 {
11928 arg3 = wxString_in_helper(obj2);
11929 if (arg3 == NULL) SWIG_fail;
11930 temp3 = true;
11931 }
11932 if (obj3) {
11933 {
11934 arg4 = (int)(SWIG_As_int(obj3));
11935 if (SWIG_arg_fail(4)) SWIG_fail;
11936 }
11937 }
11938 {
11939 PyThreadState* __tstate = wxPyBeginAllowThreads();
11940 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11941
11942 wxPyEndAllowThreads(__tstate);
11943 if (PyErr_Occurred()) SWIG_fail;
11944 }
11945 {
11946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11947 }
11948 {
11949 if (created2)
11950 delete arg2;
11951 }
11952 {
11953 if (temp3)
11954 delete arg3;
11955 }
11956 return resultobj;
11957 fail:
11958 {
11959 if (created2)
11960 delete arg2;
11961 }
11962 {
11963 if (temp3)
11964 delete arg3;
11965 }
11966 return NULL;
11967 }
11968
11969
11970 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11971 PyObject *resultobj;
11972 wxImage *arg1 = (wxImage *) 0 ;
11973 bool result;
11974 PyObject * obj0 = 0 ;
11975 char *kwnames[] = {
11976 (char *) "self", NULL
11977 };
11978
11979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11981 if (SWIG_arg_fail(1)) SWIG_fail;
11982 {
11983 PyThreadState* __tstate = wxPyBeginAllowThreads();
11984 result = (bool)(arg1)->Ok();
11985
11986 wxPyEndAllowThreads(__tstate);
11987 if (PyErr_Occurred()) SWIG_fail;
11988 }
11989 {
11990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11991 }
11992 return resultobj;
11993 fail:
11994 return NULL;
11995 }
11996
11997
11998 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj;
12000 wxImage *arg1 = (wxImage *) 0 ;
12001 int result;
12002 PyObject * obj0 = 0 ;
12003 char *kwnames[] = {
12004 (char *) "self", NULL
12005 };
12006
12007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12009 if (SWIG_arg_fail(1)) SWIG_fail;
12010 {
12011 PyThreadState* __tstate = wxPyBeginAllowThreads();
12012 result = (int)(arg1)->GetWidth();
12013
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 {
12018 resultobj = SWIG_From_int((int)(result));
12019 }
12020 return resultobj;
12021 fail:
12022 return NULL;
12023 }
12024
12025
12026 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12027 PyObject *resultobj;
12028 wxImage *arg1 = (wxImage *) 0 ;
12029 int result;
12030 PyObject * obj0 = 0 ;
12031 char *kwnames[] = {
12032 (char *) "self", NULL
12033 };
12034
12035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12037 if (SWIG_arg_fail(1)) SWIG_fail;
12038 {
12039 PyThreadState* __tstate = wxPyBeginAllowThreads();
12040 result = (int)(arg1)->GetHeight();
12041
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 {
12046 resultobj = SWIG_From_int((int)(result));
12047 }
12048 return resultobj;
12049 fail:
12050 return NULL;
12051 }
12052
12053
12054 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12055 PyObject *resultobj;
12056 wxImage *arg1 = (wxImage *) 0 ;
12057 wxSize result;
12058 PyObject * obj0 = 0 ;
12059 char *kwnames[] = {
12060 (char *) "self", NULL
12061 };
12062
12063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12065 if (SWIG_arg_fail(1)) SWIG_fail;
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 result = wxImage_GetSize(arg1);
12069
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 {
12074 wxSize * resultptr;
12075 resultptr = new wxSize((wxSize &)(result));
12076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12077 }
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12085 PyObject *resultobj;
12086 wxImage *arg1 = (wxImage *) 0 ;
12087 wxRect *arg2 = 0 ;
12088 SwigValueWrapper<wxImage > result;
12089 wxRect temp2 ;
12090 PyObject * obj0 = 0 ;
12091 PyObject * obj1 = 0 ;
12092 char *kwnames[] = {
12093 (char *) "self",(char *) "rect", NULL
12094 };
12095
12096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12098 if (SWIG_arg_fail(1)) SWIG_fail;
12099 {
12100 arg2 = &temp2;
12101 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12102 }
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12106
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 {
12111 wxImage * resultptr;
12112 resultptr = new wxImage((wxImage &)(result));
12113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12114 }
12115 return resultobj;
12116 fail:
12117 return NULL;
12118 }
12119
12120
12121 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12122 PyObject *resultobj;
12123 wxImage *arg1 = (wxImage *) 0 ;
12124 SwigValueWrapper<wxImage > result;
12125 PyObject * obj0 = 0 ;
12126 char *kwnames[] = {
12127 (char *) "self", NULL
12128 };
12129
12130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12132 if (SWIG_arg_fail(1)) SWIG_fail;
12133 {
12134 PyThreadState* __tstate = wxPyBeginAllowThreads();
12135 result = (arg1)->Copy();
12136
12137 wxPyEndAllowThreads(__tstate);
12138 if (PyErr_Occurred()) SWIG_fail;
12139 }
12140 {
12141 wxImage * resultptr;
12142 resultptr = new wxImage((wxImage &)(result));
12143 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12144 }
12145 return resultobj;
12146 fail:
12147 return NULL;
12148 }
12149
12150
12151 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12152 PyObject *resultobj;
12153 wxImage *arg1 = (wxImage *) 0 ;
12154 wxImage *arg2 = 0 ;
12155 int arg3 ;
12156 int arg4 ;
12157 PyObject * obj0 = 0 ;
12158 PyObject * obj1 = 0 ;
12159 PyObject * obj2 = 0 ;
12160 PyObject * obj3 = 0 ;
12161 char *kwnames[] = {
12162 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12163 };
12164
12165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12167 if (SWIG_arg_fail(1)) SWIG_fail;
12168 {
12169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12170 if (SWIG_arg_fail(2)) SWIG_fail;
12171 if (arg2 == NULL) {
12172 SWIG_null_ref("wxImage");
12173 }
12174 if (SWIG_arg_fail(2)) SWIG_fail;
12175 }
12176 {
12177 arg3 = (int)(SWIG_As_int(obj2));
12178 if (SWIG_arg_fail(3)) SWIG_fail;
12179 }
12180 {
12181 arg4 = (int)(SWIG_As_int(obj3));
12182 if (SWIG_arg_fail(4)) SWIG_fail;
12183 }
12184 {
12185 PyThreadState* __tstate = wxPyBeginAllowThreads();
12186 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12187
12188 wxPyEndAllowThreads(__tstate);
12189 if (PyErr_Occurred()) SWIG_fail;
12190 }
12191 Py_INCREF(Py_None); resultobj = Py_None;
12192 return resultobj;
12193 fail:
12194 return NULL;
12195 }
12196
12197
12198 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12199 PyObject *resultobj;
12200 wxImage *arg1 = (wxImage *) 0 ;
12201 PyObject *result;
12202 PyObject * obj0 = 0 ;
12203 char *kwnames[] = {
12204 (char *) "self", NULL
12205 };
12206
12207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12209 if (SWIG_arg_fail(1)) SWIG_fail;
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 result = (PyObject *)wxImage_GetData(arg1);
12213
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 resultobj = result;
12218 return resultobj;
12219 fail:
12220 return NULL;
12221 }
12222
12223
12224 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12225 PyObject *resultobj;
12226 wxImage *arg1 = (wxImage *) 0 ;
12227 PyObject *arg2 = (PyObject *) 0 ;
12228 PyObject * obj0 = 0 ;
12229 PyObject * obj1 = 0 ;
12230 char *kwnames[] = {
12231 (char *) "self",(char *) "data", NULL
12232 };
12233
12234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12236 if (SWIG_arg_fail(1)) SWIG_fail;
12237 arg2 = obj1;
12238 {
12239 PyThreadState* __tstate = wxPyBeginAllowThreads();
12240 wxImage_SetData(arg1,arg2);
12241
12242 wxPyEndAllowThreads(__tstate);
12243 if (PyErr_Occurred()) SWIG_fail;
12244 }
12245 Py_INCREF(Py_None); resultobj = Py_None;
12246 return resultobj;
12247 fail:
12248 return NULL;
12249 }
12250
12251
12252 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12253 PyObject *resultobj;
12254 wxImage *arg1 = (wxImage *) 0 ;
12255 PyObject *result;
12256 PyObject * obj0 = 0 ;
12257 char *kwnames[] = {
12258 (char *) "self", NULL
12259 };
12260
12261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12263 if (SWIG_arg_fail(1)) SWIG_fail;
12264 {
12265 PyThreadState* __tstate = wxPyBeginAllowThreads();
12266 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12267
12268 wxPyEndAllowThreads(__tstate);
12269 if (PyErr_Occurred()) SWIG_fail;
12270 }
12271 resultobj = result;
12272 return resultobj;
12273 fail:
12274 return NULL;
12275 }
12276
12277
12278 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12279 PyObject *resultobj;
12280 wxImage *arg1 = (wxImage *) 0 ;
12281 PyObject *arg2 = (PyObject *) 0 ;
12282 PyObject * obj0 = 0 ;
12283 PyObject * obj1 = 0 ;
12284 char *kwnames[] = {
12285 (char *) "self",(char *) "data", NULL
12286 };
12287
12288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12290 if (SWIG_arg_fail(1)) SWIG_fail;
12291 arg2 = obj1;
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 wxImage_SetDataBuffer(arg1,arg2);
12295
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 Py_INCREF(Py_None); resultobj = Py_None;
12300 return resultobj;
12301 fail:
12302 return NULL;
12303 }
12304
12305
12306 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12307 PyObject *resultobj;
12308 wxImage *arg1 = (wxImage *) 0 ;
12309 PyObject *result;
12310 PyObject * obj0 = 0 ;
12311 char *kwnames[] = {
12312 (char *) "self", NULL
12313 };
12314
12315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12317 if (SWIG_arg_fail(1)) SWIG_fail;
12318 {
12319 PyThreadState* __tstate = wxPyBeginAllowThreads();
12320 result = (PyObject *)wxImage_GetAlphaData(arg1);
12321
12322 wxPyEndAllowThreads(__tstate);
12323 if (PyErr_Occurred()) SWIG_fail;
12324 }
12325 resultobj = result;
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12333 PyObject *resultobj;
12334 wxImage *arg1 = (wxImage *) 0 ;
12335 PyObject *arg2 = (PyObject *) 0 ;
12336 PyObject * obj0 = 0 ;
12337 PyObject * obj1 = 0 ;
12338 char *kwnames[] = {
12339 (char *) "self",(char *) "data", NULL
12340 };
12341
12342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12344 if (SWIG_arg_fail(1)) SWIG_fail;
12345 arg2 = obj1;
12346 {
12347 PyThreadState* __tstate = wxPyBeginAllowThreads();
12348 wxImage_SetAlphaData(arg1,arg2);
12349
12350 wxPyEndAllowThreads(__tstate);
12351 if (PyErr_Occurred()) SWIG_fail;
12352 }
12353 Py_INCREF(Py_None); resultobj = Py_None;
12354 return resultobj;
12355 fail:
12356 return NULL;
12357 }
12358
12359
12360 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12361 PyObject *resultobj;
12362 wxImage *arg1 = (wxImage *) 0 ;
12363 PyObject *result;
12364 PyObject * obj0 = 0 ;
12365 char *kwnames[] = {
12366 (char *) "self", NULL
12367 };
12368
12369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12371 if (SWIG_arg_fail(1)) SWIG_fail;
12372 {
12373 PyThreadState* __tstate = wxPyBeginAllowThreads();
12374 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12375
12376 wxPyEndAllowThreads(__tstate);
12377 if (PyErr_Occurred()) SWIG_fail;
12378 }
12379 resultobj = result;
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12387 PyObject *resultobj;
12388 wxImage *arg1 = (wxImage *) 0 ;
12389 PyObject *arg2 = (PyObject *) 0 ;
12390 PyObject * obj0 = 0 ;
12391 PyObject * obj1 = 0 ;
12392 char *kwnames[] = {
12393 (char *) "self",(char *) "data", NULL
12394 };
12395
12396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12398 if (SWIG_arg_fail(1)) SWIG_fail;
12399 arg2 = obj1;
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 wxImage_SetAlphaBuffer(arg1,arg2);
12403
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 Py_INCREF(Py_None); resultobj = Py_None;
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj;
12416 wxImage *arg1 = (wxImage *) 0 ;
12417 unsigned char arg2 ;
12418 unsigned char arg3 ;
12419 unsigned char arg4 ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 PyObject * obj2 = 0 ;
12423 PyObject * obj3 = 0 ;
12424 char *kwnames[] = {
12425 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12426 };
12427
12428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12430 if (SWIG_arg_fail(1)) SWIG_fail;
12431 {
12432 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12433 if (SWIG_arg_fail(2)) SWIG_fail;
12434 }
12435 {
12436 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12437 if (SWIG_arg_fail(3)) SWIG_fail;
12438 }
12439 {
12440 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12441 if (SWIG_arg_fail(4)) SWIG_fail;
12442 }
12443 {
12444 PyThreadState* __tstate = wxPyBeginAllowThreads();
12445 (arg1)->SetMaskColour(arg2,arg3,arg4);
12446
12447 wxPyEndAllowThreads(__tstate);
12448 if (PyErr_Occurred()) SWIG_fail;
12449 }
12450 Py_INCREF(Py_None); resultobj = Py_None;
12451 return resultobj;
12452 fail:
12453 return NULL;
12454 }
12455
12456
12457 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12458 PyObject *resultobj;
12459 wxImage *arg1 = (wxImage *) 0 ;
12460 unsigned char result;
12461 PyObject * obj0 = 0 ;
12462 char *kwnames[] = {
12463 (char *) "self", NULL
12464 };
12465
12466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12468 if (SWIG_arg_fail(1)) SWIG_fail;
12469 {
12470 PyThreadState* __tstate = wxPyBeginAllowThreads();
12471 result = (unsigned char)(arg1)->GetMaskRed();
12472
12473 wxPyEndAllowThreads(__tstate);
12474 if (PyErr_Occurred()) SWIG_fail;
12475 }
12476 {
12477 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12478 }
12479 return resultobj;
12480 fail:
12481 return NULL;
12482 }
12483
12484
12485 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12486 PyObject *resultobj;
12487 wxImage *arg1 = (wxImage *) 0 ;
12488 unsigned char result;
12489 PyObject * obj0 = 0 ;
12490 char *kwnames[] = {
12491 (char *) "self", NULL
12492 };
12493
12494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12496 if (SWIG_arg_fail(1)) SWIG_fail;
12497 {
12498 PyThreadState* __tstate = wxPyBeginAllowThreads();
12499 result = (unsigned char)(arg1)->GetMaskGreen();
12500
12501 wxPyEndAllowThreads(__tstate);
12502 if (PyErr_Occurred()) SWIG_fail;
12503 }
12504 {
12505 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12506 }
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj;
12515 wxImage *arg1 = (wxImage *) 0 ;
12516 unsigned char result;
12517 PyObject * obj0 = 0 ;
12518 char *kwnames[] = {
12519 (char *) "self", NULL
12520 };
12521
12522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12524 if (SWIG_arg_fail(1)) SWIG_fail;
12525 {
12526 PyThreadState* __tstate = wxPyBeginAllowThreads();
12527 result = (unsigned char)(arg1)->GetMaskBlue();
12528
12529 wxPyEndAllowThreads(__tstate);
12530 if (PyErr_Occurred()) SWIG_fail;
12531 }
12532 {
12533 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12534 }
12535 return resultobj;
12536 fail:
12537 return NULL;
12538 }
12539
12540
12541 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12542 PyObject *resultobj;
12543 wxImage *arg1 = (wxImage *) 0 ;
12544 bool arg2 = (bool) true ;
12545 PyObject * obj0 = 0 ;
12546 PyObject * obj1 = 0 ;
12547 char *kwnames[] = {
12548 (char *) "self",(char *) "mask", NULL
12549 };
12550
12551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12553 if (SWIG_arg_fail(1)) SWIG_fail;
12554 if (obj1) {
12555 {
12556 arg2 = (bool)(SWIG_As_bool(obj1));
12557 if (SWIG_arg_fail(2)) SWIG_fail;
12558 }
12559 }
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 (arg1)->SetMask(arg2);
12563
12564 wxPyEndAllowThreads(__tstate);
12565 if (PyErr_Occurred()) SWIG_fail;
12566 }
12567 Py_INCREF(Py_None); resultobj = Py_None;
12568 return resultobj;
12569 fail:
12570 return NULL;
12571 }
12572
12573
12574 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12575 PyObject *resultobj;
12576 wxImage *arg1 = (wxImage *) 0 ;
12577 bool result;
12578 PyObject * obj0 = 0 ;
12579 char *kwnames[] = {
12580 (char *) "self", NULL
12581 };
12582
12583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12585 if (SWIG_arg_fail(1)) SWIG_fail;
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 result = (bool)(arg1)->HasMask();
12589
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 {
12594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12595 }
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12603 PyObject *resultobj;
12604 wxImage *arg1 = (wxImage *) 0 ;
12605 double arg2 ;
12606 wxPoint *arg3 = 0 ;
12607 bool arg4 = (bool) true ;
12608 wxPoint *arg5 = (wxPoint *) NULL ;
12609 SwigValueWrapper<wxImage > result;
12610 wxPoint temp3 ;
12611 PyObject * obj0 = 0 ;
12612 PyObject * obj1 = 0 ;
12613 PyObject * obj2 = 0 ;
12614 PyObject * obj3 = 0 ;
12615 PyObject * obj4 = 0 ;
12616 char *kwnames[] = {
12617 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12618 };
12619
12620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12622 if (SWIG_arg_fail(1)) SWIG_fail;
12623 {
12624 arg2 = (double)(SWIG_As_double(obj1));
12625 if (SWIG_arg_fail(2)) SWIG_fail;
12626 }
12627 {
12628 arg3 = &temp3;
12629 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12630 }
12631 if (obj3) {
12632 {
12633 arg4 = (bool)(SWIG_As_bool(obj3));
12634 if (SWIG_arg_fail(4)) SWIG_fail;
12635 }
12636 }
12637 if (obj4) {
12638 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12639 if (SWIG_arg_fail(5)) SWIG_fail;
12640 }
12641 {
12642 PyThreadState* __tstate = wxPyBeginAllowThreads();
12643 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12644
12645 wxPyEndAllowThreads(__tstate);
12646 if (PyErr_Occurred()) SWIG_fail;
12647 }
12648 {
12649 wxImage * resultptr;
12650 resultptr = new wxImage((wxImage &)(result));
12651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12652 }
12653 return resultobj;
12654 fail:
12655 return NULL;
12656 }
12657
12658
12659 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12660 PyObject *resultobj;
12661 wxImage *arg1 = (wxImage *) 0 ;
12662 bool arg2 = (bool) true ;
12663 SwigValueWrapper<wxImage > result;
12664 PyObject * obj0 = 0 ;
12665 PyObject * obj1 = 0 ;
12666 char *kwnames[] = {
12667 (char *) "self",(char *) "clockwise", NULL
12668 };
12669
12670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12672 if (SWIG_arg_fail(1)) SWIG_fail;
12673 if (obj1) {
12674 {
12675 arg2 = (bool)(SWIG_As_bool(obj1));
12676 if (SWIG_arg_fail(2)) SWIG_fail;
12677 }
12678 }
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (arg1)->Rotate90(arg2);
12682
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 wxImage * resultptr;
12688 resultptr = new wxImage((wxImage &)(result));
12689 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12690 }
12691 return resultobj;
12692 fail:
12693 return NULL;
12694 }
12695
12696
12697 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12698 PyObject *resultobj;
12699 wxImage *arg1 = (wxImage *) 0 ;
12700 bool arg2 = (bool) true ;
12701 SwigValueWrapper<wxImage > result;
12702 PyObject * obj0 = 0 ;
12703 PyObject * obj1 = 0 ;
12704 char *kwnames[] = {
12705 (char *) "self",(char *) "horizontally", NULL
12706 };
12707
12708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12710 if (SWIG_arg_fail(1)) SWIG_fail;
12711 if (obj1) {
12712 {
12713 arg2 = (bool)(SWIG_As_bool(obj1));
12714 if (SWIG_arg_fail(2)) SWIG_fail;
12715 }
12716 }
12717 {
12718 PyThreadState* __tstate = wxPyBeginAllowThreads();
12719 result = (arg1)->Mirror(arg2);
12720
12721 wxPyEndAllowThreads(__tstate);
12722 if (PyErr_Occurred()) SWIG_fail;
12723 }
12724 {
12725 wxImage * resultptr;
12726 resultptr = new wxImage((wxImage &)(result));
12727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12728 }
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12736 PyObject *resultobj;
12737 wxImage *arg1 = (wxImage *) 0 ;
12738 unsigned char arg2 ;
12739 unsigned char arg3 ;
12740 unsigned char arg4 ;
12741 unsigned char arg5 ;
12742 unsigned char arg6 ;
12743 unsigned char arg7 ;
12744 PyObject * obj0 = 0 ;
12745 PyObject * obj1 = 0 ;
12746 PyObject * obj2 = 0 ;
12747 PyObject * obj3 = 0 ;
12748 PyObject * obj4 = 0 ;
12749 PyObject * obj5 = 0 ;
12750 PyObject * obj6 = 0 ;
12751 char *kwnames[] = {
12752 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12753 };
12754
12755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12757 if (SWIG_arg_fail(1)) SWIG_fail;
12758 {
12759 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12760 if (SWIG_arg_fail(2)) SWIG_fail;
12761 }
12762 {
12763 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12764 if (SWIG_arg_fail(3)) SWIG_fail;
12765 }
12766 {
12767 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12768 if (SWIG_arg_fail(4)) SWIG_fail;
12769 }
12770 {
12771 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12772 if (SWIG_arg_fail(5)) SWIG_fail;
12773 }
12774 {
12775 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12776 if (SWIG_arg_fail(6)) SWIG_fail;
12777 }
12778 {
12779 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12780 if (SWIG_arg_fail(7)) SWIG_fail;
12781 }
12782 {
12783 PyThreadState* __tstate = wxPyBeginAllowThreads();
12784 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12785
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 Py_INCREF(Py_None); resultobj = Py_None;
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj;
12798 wxImage *arg1 = (wxImage *) 0 ;
12799 unsigned char arg2 ;
12800 unsigned char arg3 ;
12801 unsigned char arg4 ;
12802 SwigValueWrapper<wxImage > result;
12803 PyObject * obj0 = 0 ;
12804 PyObject * obj1 = 0 ;
12805 PyObject * obj2 = 0 ;
12806 PyObject * obj3 = 0 ;
12807 char *kwnames[] = {
12808 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12809 };
12810
12811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12813 if (SWIG_arg_fail(1)) SWIG_fail;
12814 {
12815 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12816 if (SWIG_arg_fail(2)) SWIG_fail;
12817 }
12818 {
12819 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12820 if (SWIG_arg_fail(3)) SWIG_fail;
12821 }
12822 {
12823 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12824 if (SWIG_arg_fail(4)) SWIG_fail;
12825 }
12826 {
12827 PyThreadState* __tstate = wxPyBeginAllowThreads();
12828 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12829
12830 wxPyEndAllowThreads(__tstate);
12831 if (PyErr_Occurred()) SWIG_fail;
12832 }
12833 {
12834 wxImage * resultptr;
12835 resultptr = new wxImage((wxImage &)(result));
12836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12837 }
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12845 PyObject *resultobj;
12846 wxImage *arg1 = (wxImage *) 0 ;
12847 wxString *arg2 = 0 ;
12848 wxString *arg3 = 0 ;
12849 bool temp2 = false ;
12850 bool temp3 = false ;
12851 PyObject * obj0 = 0 ;
12852 PyObject * obj1 = 0 ;
12853 PyObject * obj2 = 0 ;
12854 char *kwnames[] = {
12855 (char *) "self",(char *) "name",(char *) "value", NULL
12856 };
12857
12858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12860 if (SWIG_arg_fail(1)) SWIG_fail;
12861 {
12862 arg2 = wxString_in_helper(obj1);
12863 if (arg2 == NULL) SWIG_fail;
12864 temp2 = true;
12865 }
12866 {
12867 arg3 = wxString_in_helper(obj2);
12868 if (arg3 == NULL) SWIG_fail;
12869 temp3 = true;
12870 }
12871 {
12872 PyThreadState* __tstate = wxPyBeginAllowThreads();
12873 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12874
12875 wxPyEndAllowThreads(__tstate);
12876 if (PyErr_Occurred()) SWIG_fail;
12877 }
12878 Py_INCREF(Py_None); resultobj = Py_None;
12879 {
12880 if (temp2)
12881 delete arg2;
12882 }
12883 {
12884 if (temp3)
12885 delete arg3;
12886 }
12887 return resultobj;
12888 fail:
12889 {
12890 if (temp2)
12891 delete arg2;
12892 }
12893 {
12894 if (temp3)
12895 delete arg3;
12896 }
12897 return NULL;
12898 }
12899
12900
12901 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj;
12903 wxImage *arg1 = (wxImage *) 0 ;
12904 wxString *arg2 = 0 ;
12905 int arg3 ;
12906 bool temp2 = false ;
12907 PyObject * obj0 = 0 ;
12908 PyObject * obj1 = 0 ;
12909 PyObject * obj2 = 0 ;
12910 char *kwnames[] = {
12911 (char *) "self",(char *) "name",(char *) "value", NULL
12912 };
12913
12914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12916 if (SWIG_arg_fail(1)) SWIG_fail;
12917 {
12918 arg2 = wxString_in_helper(obj1);
12919 if (arg2 == NULL) SWIG_fail;
12920 temp2 = true;
12921 }
12922 {
12923 arg3 = (int)(SWIG_As_int(obj2));
12924 if (SWIG_arg_fail(3)) SWIG_fail;
12925 }
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 (arg1)->SetOption((wxString const &)*arg2,arg3);
12929
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 Py_INCREF(Py_None); resultobj = Py_None;
12934 {
12935 if (temp2)
12936 delete arg2;
12937 }
12938 return resultobj;
12939 fail:
12940 {
12941 if (temp2)
12942 delete arg2;
12943 }
12944 return NULL;
12945 }
12946
12947
12948 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12949 PyObject *resultobj;
12950 wxImage *arg1 = (wxImage *) 0 ;
12951 wxString *arg2 = 0 ;
12952 wxString result;
12953 bool temp2 = false ;
12954 PyObject * obj0 = 0 ;
12955 PyObject * obj1 = 0 ;
12956 char *kwnames[] = {
12957 (char *) "self",(char *) "name", NULL
12958 };
12959
12960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12962 if (SWIG_arg_fail(1)) SWIG_fail;
12963 {
12964 arg2 = wxString_in_helper(obj1);
12965 if (arg2 == NULL) SWIG_fail;
12966 temp2 = true;
12967 }
12968 {
12969 PyThreadState* __tstate = wxPyBeginAllowThreads();
12970 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12971
12972 wxPyEndAllowThreads(__tstate);
12973 if (PyErr_Occurred()) SWIG_fail;
12974 }
12975 {
12976 #if wxUSE_UNICODE
12977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12978 #else
12979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12980 #endif
12981 }
12982 {
12983 if (temp2)
12984 delete arg2;
12985 }
12986 return resultobj;
12987 fail:
12988 {
12989 if (temp2)
12990 delete arg2;
12991 }
12992 return NULL;
12993 }
12994
12995
12996 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12997 PyObject *resultobj;
12998 wxImage *arg1 = (wxImage *) 0 ;
12999 wxString *arg2 = 0 ;
13000 int result;
13001 bool temp2 = false ;
13002 PyObject * obj0 = 0 ;
13003 PyObject * obj1 = 0 ;
13004 char *kwnames[] = {
13005 (char *) "self",(char *) "name", NULL
13006 };
13007
13008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13010 if (SWIG_arg_fail(1)) SWIG_fail;
13011 {
13012 arg2 = wxString_in_helper(obj1);
13013 if (arg2 == NULL) SWIG_fail;
13014 temp2 = true;
13015 }
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13019
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 {
13024 resultobj = SWIG_From_int((int)(result));
13025 }
13026 {
13027 if (temp2)
13028 delete arg2;
13029 }
13030 return resultobj;
13031 fail:
13032 {
13033 if (temp2)
13034 delete arg2;
13035 }
13036 return NULL;
13037 }
13038
13039
13040 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13041 PyObject *resultobj;
13042 wxImage *arg1 = (wxImage *) 0 ;
13043 wxString *arg2 = 0 ;
13044 bool result;
13045 bool temp2 = false ;
13046 PyObject * obj0 = 0 ;
13047 PyObject * obj1 = 0 ;
13048 char *kwnames[] = {
13049 (char *) "self",(char *) "name", NULL
13050 };
13051
13052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13054 if (SWIG_arg_fail(1)) SWIG_fail;
13055 {
13056 arg2 = wxString_in_helper(obj1);
13057 if (arg2 == NULL) SWIG_fail;
13058 temp2 = true;
13059 }
13060 {
13061 PyThreadState* __tstate = wxPyBeginAllowThreads();
13062 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13063
13064 wxPyEndAllowThreads(__tstate);
13065 if (PyErr_Occurred()) SWIG_fail;
13066 }
13067 {
13068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13069 }
13070 {
13071 if (temp2)
13072 delete arg2;
13073 }
13074 return resultobj;
13075 fail:
13076 {
13077 if (temp2)
13078 delete arg2;
13079 }
13080 return NULL;
13081 }
13082
13083
13084 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13085 PyObject *resultobj;
13086 wxImage *arg1 = (wxImage *) 0 ;
13087 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13088 unsigned long result;
13089 PyObject * obj0 = 0 ;
13090 PyObject * obj1 = 0 ;
13091 char *kwnames[] = {
13092 (char *) "self",(char *) "stopafter", NULL
13093 };
13094
13095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13097 if (SWIG_arg_fail(1)) SWIG_fail;
13098 if (obj1) {
13099 {
13100 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13101 if (SWIG_arg_fail(2)) SWIG_fail;
13102 }
13103 }
13104 {
13105 PyThreadState* __tstate = wxPyBeginAllowThreads();
13106 result = (unsigned long)(arg1)->CountColours(arg2);
13107
13108 wxPyEndAllowThreads(__tstate);
13109 if (PyErr_Occurred()) SWIG_fail;
13110 }
13111 {
13112 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13113 }
13114 return resultobj;
13115 fail:
13116 return NULL;
13117 }
13118
13119
13120 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13121 PyObject *resultobj;
13122 wxImage *arg1 = (wxImage *) 0 ;
13123 wxImageHistogram *arg2 = 0 ;
13124 unsigned long result;
13125 PyObject * obj0 = 0 ;
13126 PyObject * obj1 = 0 ;
13127 char *kwnames[] = {
13128 (char *) "self",(char *) "h", NULL
13129 };
13130
13131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13133 if (SWIG_arg_fail(1)) SWIG_fail;
13134 {
13135 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13136 if (SWIG_arg_fail(2)) SWIG_fail;
13137 if (arg2 == NULL) {
13138 SWIG_null_ref("wxImageHistogram");
13139 }
13140 if (SWIG_arg_fail(2)) SWIG_fail;
13141 }
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13145
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 {
13150 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13151 }
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj;
13160 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13161 PyObject * obj0 = 0 ;
13162 char *kwnames[] = {
13163 (char *) "handler", NULL
13164 };
13165
13166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13168 if (SWIG_arg_fail(1)) SWIG_fail;
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 wxImage::AddHandler(arg1);
13172
13173 wxPyEndAllowThreads(__tstate);
13174 if (PyErr_Occurred()) SWIG_fail;
13175 }
13176 Py_INCREF(Py_None); resultobj = Py_None;
13177 return resultobj;
13178 fail:
13179 return NULL;
13180 }
13181
13182
13183 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13184 PyObject *resultobj;
13185 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13186 PyObject * obj0 = 0 ;
13187 char *kwnames[] = {
13188 (char *) "handler", NULL
13189 };
13190
13191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13193 if (SWIG_arg_fail(1)) SWIG_fail;
13194 {
13195 PyThreadState* __tstate = wxPyBeginAllowThreads();
13196 wxImage::InsertHandler(arg1);
13197
13198 wxPyEndAllowThreads(__tstate);
13199 if (PyErr_Occurred()) SWIG_fail;
13200 }
13201 Py_INCREF(Py_None); resultobj = Py_None;
13202 return resultobj;
13203 fail:
13204 return NULL;
13205 }
13206
13207
13208 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13209 PyObject *resultobj;
13210 wxString *arg1 = 0 ;
13211 bool result;
13212 bool temp1 = false ;
13213 PyObject * obj0 = 0 ;
13214 char *kwnames[] = {
13215 (char *) "name", NULL
13216 };
13217
13218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13219 {
13220 arg1 = wxString_in_helper(obj0);
13221 if (arg1 == NULL) SWIG_fail;
13222 temp1 = true;
13223 }
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13227
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 {
13232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13233 }
13234 {
13235 if (temp1)
13236 delete arg1;
13237 }
13238 return resultobj;
13239 fail:
13240 {
13241 if (temp1)
13242 delete arg1;
13243 }
13244 return NULL;
13245 }
13246
13247
13248 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13249 PyObject *resultobj;
13250 wxString result;
13251 char *kwnames[] = {
13252 NULL
13253 };
13254
13255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13256 {
13257 PyThreadState* __tstate = wxPyBeginAllowThreads();
13258 result = wxImage::GetImageExtWildcard();
13259
13260 wxPyEndAllowThreads(__tstate);
13261 if (PyErr_Occurred()) SWIG_fail;
13262 }
13263 {
13264 #if wxUSE_UNICODE
13265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13266 #else
13267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13268 #endif
13269 }
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13277 PyObject *resultobj;
13278 wxImage *arg1 = (wxImage *) 0 ;
13279 int arg2 = (int) -1 ;
13280 wxBitmap result;
13281 PyObject * obj0 = 0 ;
13282 PyObject * obj1 = 0 ;
13283 char *kwnames[] = {
13284 (char *) "self",(char *) "depth", NULL
13285 };
13286
13287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13289 if (SWIG_arg_fail(1)) SWIG_fail;
13290 if (obj1) {
13291 {
13292 arg2 = (int)(SWIG_As_int(obj1));
13293 if (SWIG_arg_fail(2)) SWIG_fail;
13294 }
13295 }
13296 {
13297 if (!wxPyCheckForApp()) SWIG_fail;
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 result = wxImage_ConvertToBitmap(arg1,arg2);
13300
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 {
13305 wxBitmap * resultptr;
13306 resultptr = new wxBitmap((wxBitmap &)(result));
13307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13308 }
13309 return resultobj;
13310 fail:
13311 return NULL;
13312 }
13313
13314
13315 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13316 PyObject *resultobj;
13317 wxImage *arg1 = (wxImage *) 0 ;
13318 unsigned char arg2 ;
13319 unsigned char arg3 ;
13320 unsigned char arg4 ;
13321 wxBitmap result;
13322 PyObject * obj0 = 0 ;
13323 PyObject * obj1 = 0 ;
13324 PyObject * obj2 = 0 ;
13325 PyObject * obj3 = 0 ;
13326 char *kwnames[] = {
13327 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13328 };
13329
13330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13332 if (SWIG_arg_fail(1)) SWIG_fail;
13333 {
13334 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13335 if (SWIG_arg_fail(2)) SWIG_fail;
13336 }
13337 {
13338 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13339 if (SWIG_arg_fail(3)) SWIG_fail;
13340 }
13341 {
13342 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13343 if (SWIG_arg_fail(4)) SWIG_fail;
13344 }
13345 {
13346 if (!wxPyCheckForApp()) SWIG_fail;
13347 PyThreadState* __tstate = wxPyBeginAllowThreads();
13348 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13349
13350 wxPyEndAllowThreads(__tstate);
13351 if (PyErr_Occurred()) SWIG_fail;
13352 }
13353 {
13354 wxBitmap * resultptr;
13355 resultptr = new wxBitmap((wxBitmap &)(result));
13356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13357 }
13358 return resultobj;
13359 fail:
13360 return NULL;
13361 }
13362
13363
13364 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13365 PyObject *obj;
13366 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13367 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13368 Py_INCREF(obj);
13369 return Py_BuildValue((char *)"");
13370 }
13371 static int _wrap_NullImage_set(PyObject *) {
13372 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13373 return 1;
13374 }
13375
13376
13377 static PyObject *_wrap_NullImage_get(void) {
13378 PyObject *pyobj;
13379
13380 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13381 return pyobj;
13382 }
13383
13384
13385 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13386 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13387 return 1;
13388 }
13389
13390
13391 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13392 PyObject *pyobj;
13393
13394 {
13395 #if wxUSE_UNICODE
13396 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13397 #else
13398 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13399 #endif
13400 }
13401 return pyobj;
13402 }
13403
13404
13405 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13406 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13407 return 1;
13408 }
13409
13410
13411 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13412 PyObject *pyobj;
13413
13414 {
13415 #if wxUSE_UNICODE
13416 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13417 #else
13418 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13419 #endif
13420 }
13421 return pyobj;
13422 }
13423
13424
13425 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13426 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13427 return 1;
13428 }
13429
13430
13431 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13432 PyObject *pyobj;
13433
13434 {
13435 #if wxUSE_UNICODE
13436 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13437 #else
13438 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13439 #endif
13440 }
13441 return pyobj;
13442 }
13443
13444
13445 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13446 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13447 return 1;
13448 }
13449
13450
13451 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13452 PyObject *pyobj;
13453
13454 {
13455 #if wxUSE_UNICODE
13456 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13457 #else
13458 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13459 #endif
13460 }
13461 return pyobj;
13462 }
13463
13464
13465 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13466 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13467 return 1;
13468 }
13469
13470
13471 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13472 PyObject *pyobj;
13473
13474 {
13475 #if wxUSE_UNICODE
13476 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13477 #else
13478 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13479 #endif
13480 }
13481 return pyobj;
13482 }
13483
13484
13485 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13486 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13487 return 1;
13488 }
13489
13490
13491 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13492 PyObject *pyobj;
13493
13494 {
13495 #if wxUSE_UNICODE
13496 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13497 #else
13498 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13499 #endif
13500 }
13501 return pyobj;
13502 }
13503
13504
13505 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13506 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13507 return 1;
13508 }
13509
13510
13511 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13512 PyObject *pyobj;
13513
13514 {
13515 #if wxUSE_UNICODE
13516 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13517 #else
13518 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13519 #endif
13520 }
13521 return pyobj;
13522 }
13523
13524
13525 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13526 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13527 return 1;
13528 }
13529
13530
13531 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13532 PyObject *pyobj;
13533
13534 {
13535 #if wxUSE_UNICODE
13536 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13537 #else
13538 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13539 #endif
13540 }
13541 return pyobj;
13542 }
13543
13544
13545 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13546 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13547 return 1;
13548 }
13549
13550
13551 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13552 PyObject *pyobj;
13553
13554 {
13555 #if wxUSE_UNICODE
13556 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13557 #else
13558 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13559 #endif
13560 }
13561 return pyobj;
13562 }
13563
13564
13565 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13566 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13567 return 1;
13568 }
13569
13570
13571 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13572 PyObject *pyobj;
13573
13574 {
13575 #if wxUSE_UNICODE
13576 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13577 #else
13578 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13579 #endif
13580 }
13581 return pyobj;
13582 }
13583
13584
13585 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13586 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13587 return 1;
13588 }
13589
13590
13591 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13592 PyObject *pyobj;
13593
13594 {
13595 #if wxUSE_UNICODE
13596 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13597 #else
13598 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13599 #endif
13600 }
13601 return pyobj;
13602 }
13603
13604
13605 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13606 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13607 return 1;
13608 }
13609
13610
13611 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13612 PyObject *pyobj;
13613
13614 {
13615 #if wxUSE_UNICODE
13616 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13617 #else
13618 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13619 #endif
13620 }
13621 return pyobj;
13622 }
13623
13624
13625 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj;
13627 wxBMPHandler *result;
13628 char *kwnames[] = {
13629 NULL
13630 };
13631
13632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13633 {
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 result = (wxBMPHandler *)new wxBMPHandler();
13636
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13648 PyObject *obj;
13649 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13650 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13651 Py_INCREF(obj);
13652 return Py_BuildValue((char *)"");
13653 }
13654 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13655 PyObject *resultobj;
13656 wxICOHandler *result;
13657 char *kwnames[] = {
13658 NULL
13659 };
13660
13661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13662 {
13663 PyThreadState* __tstate = wxPyBeginAllowThreads();
13664 result = (wxICOHandler *)new wxICOHandler();
13665
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13670 return resultobj;
13671 fail:
13672 return NULL;
13673 }
13674
13675
13676 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13677 PyObject *obj;
13678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13679 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13680 Py_INCREF(obj);
13681 return Py_BuildValue((char *)"");
13682 }
13683 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13684 PyObject *resultobj;
13685 wxCURHandler *result;
13686 char *kwnames[] = {
13687 NULL
13688 };
13689
13690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13691 {
13692 PyThreadState* __tstate = wxPyBeginAllowThreads();
13693 result = (wxCURHandler *)new wxCURHandler();
13694
13695 wxPyEndAllowThreads(__tstate);
13696 if (PyErr_Occurred()) SWIG_fail;
13697 }
13698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13699 return resultobj;
13700 fail:
13701 return NULL;
13702 }
13703
13704
13705 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13706 PyObject *obj;
13707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13708 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13709 Py_INCREF(obj);
13710 return Py_BuildValue((char *)"");
13711 }
13712 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13713 PyObject *resultobj;
13714 wxANIHandler *result;
13715 char *kwnames[] = {
13716 NULL
13717 };
13718
13719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13720 {
13721 PyThreadState* __tstate = wxPyBeginAllowThreads();
13722 result = (wxANIHandler *)new wxANIHandler();
13723
13724 wxPyEndAllowThreads(__tstate);
13725 if (PyErr_Occurred()) SWIG_fail;
13726 }
13727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13728 return resultobj;
13729 fail:
13730 return NULL;
13731 }
13732
13733
13734 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13735 PyObject *obj;
13736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13737 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13738 Py_INCREF(obj);
13739 return Py_BuildValue((char *)"");
13740 }
13741 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj;
13743 wxPNGHandler *result;
13744 char *kwnames[] = {
13745 NULL
13746 };
13747
13748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13749 {
13750 PyThreadState* __tstate = wxPyBeginAllowThreads();
13751 result = (wxPNGHandler *)new wxPNGHandler();
13752
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13764 PyObject *obj;
13765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13766 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13767 Py_INCREF(obj);
13768 return Py_BuildValue((char *)"");
13769 }
13770 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13771 PyObject *resultobj;
13772 wxGIFHandler *result;
13773 char *kwnames[] = {
13774 NULL
13775 };
13776
13777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13778 {
13779 PyThreadState* __tstate = wxPyBeginAllowThreads();
13780 result = (wxGIFHandler *)new wxGIFHandler();
13781
13782 wxPyEndAllowThreads(__tstate);
13783 if (PyErr_Occurred()) SWIG_fail;
13784 }
13785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13786 return resultobj;
13787 fail:
13788 return NULL;
13789 }
13790
13791
13792 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13793 PyObject *obj;
13794 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13795 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13796 Py_INCREF(obj);
13797 return Py_BuildValue((char *)"");
13798 }
13799 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13800 PyObject *resultobj;
13801 wxPCXHandler *result;
13802 char *kwnames[] = {
13803 NULL
13804 };
13805
13806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13807 {
13808 PyThreadState* __tstate = wxPyBeginAllowThreads();
13809 result = (wxPCXHandler *)new wxPCXHandler();
13810
13811 wxPyEndAllowThreads(__tstate);
13812 if (PyErr_Occurred()) SWIG_fail;
13813 }
13814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13815 return resultobj;
13816 fail:
13817 return NULL;
13818 }
13819
13820
13821 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13822 PyObject *obj;
13823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13824 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13825 Py_INCREF(obj);
13826 return Py_BuildValue((char *)"");
13827 }
13828 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj;
13830 wxJPEGHandler *result;
13831 char *kwnames[] = {
13832 NULL
13833 };
13834
13835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13836 {
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 result = (wxJPEGHandler *)new wxJPEGHandler();
13839
13840 wxPyEndAllowThreads(__tstate);
13841 if (PyErr_Occurred()) SWIG_fail;
13842 }
13843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13844 return resultobj;
13845 fail:
13846 return NULL;
13847 }
13848
13849
13850 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13851 PyObject *obj;
13852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13853 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13854 Py_INCREF(obj);
13855 return Py_BuildValue((char *)"");
13856 }
13857 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13858 PyObject *resultobj;
13859 wxPNMHandler *result;
13860 char *kwnames[] = {
13861 NULL
13862 };
13863
13864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13865 {
13866 PyThreadState* __tstate = wxPyBeginAllowThreads();
13867 result = (wxPNMHandler *)new wxPNMHandler();
13868
13869 wxPyEndAllowThreads(__tstate);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 }
13872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13873 return resultobj;
13874 fail:
13875 return NULL;
13876 }
13877
13878
13879 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13880 PyObject *obj;
13881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13882 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13883 Py_INCREF(obj);
13884 return Py_BuildValue((char *)"");
13885 }
13886 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj;
13888 wxXPMHandler *result;
13889 char *kwnames[] = {
13890 NULL
13891 };
13892
13893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13894 {
13895 PyThreadState* __tstate = wxPyBeginAllowThreads();
13896 result = (wxXPMHandler *)new wxXPMHandler();
13897
13898 wxPyEndAllowThreads(__tstate);
13899 if (PyErr_Occurred()) SWIG_fail;
13900 }
13901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13902 return resultobj;
13903 fail:
13904 return NULL;
13905 }
13906
13907
13908 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13909 PyObject *obj;
13910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13911 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13912 Py_INCREF(obj);
13913 return Py_BuildValue((char *)"");
13914 }
13915 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13916 PyObject *resultobj;
13917 wxTIFFHandler *result;
13918 char *kwnames[] = {
13919 NULL
13920 };
13921
13922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 result = (wxTIFFHandler *)new wxTIFFHandler();
13926
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13938 PyObject *obj;
13939 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13940 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13941 Py_INCREF(obj);
13942 return Py_BuildValue((char *)"");
13943 }
13944 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13945 PyObject *resultobj;
13946 wxImage *arg1 = 0 ;
13947 wxImage *arg2 = 0 ;
13948 int arg3 = (int) 236 ;
13949 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13950 bool result;
13951 PyObject * obj0 = 0 ;
13952 PyObject * obj1 = 0 ;
13953 PyObject * obj2 = 0 ;
13954 PyObject * obj3 = 0 ;
13955 char *kwnames[] = {
13956 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13957 };
13958
13959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13960 {
13961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13962 if (SWIG_arg_fail(1)) SWIG_fail;
13963 if (arg1 == NULL) {
13964 SWIG_null_ref("wxImage");
13965 }
13966 if (SWIG_arg_fail(1)) SWIG_fail;
13967 }
13968 {
13969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13970 if (SWIG_arg_fail(2)) SWIG_fail;
13971 if (arg2 == NULL) {
13972 SWIG_null_ref("wxImage");
13973 }
13974 if (SWIG_arg_fail(2)) SWIG_fail;
13975 }
13976 if (obj2) {
13977 {
13978 arg3 = (int)(SWIG_As_int(obj2));
13979 if (SWIG_arg_fail(3)) SWIG_fail;
13980 }
13981 }
13982 if (obj3) {
13983 {
13984 arg4 = (int)(SWIG_As_int(obj3));
13985 if (SWIG_arg_fail(4)) SWIG_fail;
13986 }
13987 }
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
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 * Quantize_swigregister(PyObject *, PyObject *args) {
14005 PyObject *obj;
14006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14007 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14008 Py_INCREF(obj);
14009 return Py_BuildValue((char *)"");
14010 }
14011 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14012 PyObject *resultobj;
14013 wxEvtHandler *result;
14014 char *kwnames[] = {
14015 NULL
14016 };
14017
14018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 result = (wxEvtHandler *)new wxEvtHandler();
14022
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj;
14035 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14036 wxEvtHandler *result;
14037 PyObject * obj0 = 0 ;
14038 char *kwnames[] = {
14039 (char *) "self", NULL
14040 };
14041
14042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14044 if (SWIG_arg_fail(1)) SWIG_fail;
14045 {
14046 PyThreadState* __tstate = wxPyBeginAllowThreads();
14047 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14048
14049 wxPyEndAllowThreads(__tstate);
14050 if (PyErr_Occurred()) SWIG_fail;
14051 }
14052 {
14053 resultobj = wxPyMake_wxObject(result, 0);
14054 }
14055 return resultobj;
14056 fail:
14057 return NULL;
14058 }
14059
14060
14061 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj;
14063 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14064 wxEvtHandler *result;
14065 PyObject * obj0 = 0 ;
14066 char *kwnames[] = {
14067 (char *) "self", NULL
14068 };
14069
14070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14072 if (SWIG_arg_fail(1)) SWIG_fail;
14073 {
14074 PyThreadState* __tstate = wxPyBeginAllowThreads();
14075 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14076
14077 wxPyEndAllowThreads(__tstate);
14078 if (PyErr_Occurred()) SWIG_fail;
14079 }
14080 {
14081 resultobj = wxPyMake_wxObject(result, 0);
14082 }
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj;
14091 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14092 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14093 PyObject * obj0 = 0 ;
14094 PyObject * obj1 = 0 ;
14095 char *kwnames[] = {
14096 (char *) "self",(char *) "handler", NULL
14097 };
14098
14099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14101 if (SWIG_arg_fail(1)) SWIG_fail;
14102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14103 if (SWIG_arg_fail(2)) SWIG_fail;
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 (arg1)->SetNextHandler(arg2);
14107
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 Py_INCREF(Py_None); resultobj = Py_None;
14112 return resultobj;
14113 fail:
14114 return NULL;
14115 }
14116
14117
14118 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14119 PyObject *resultobj;
14120 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14121 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14122 PyObject * obj0 = 0 ;
14123 PyObject * obj1 = 0 ;
14124 char *kwnames[] = {
14125 (char *) "self",(char *) "handler", NULL
14126 };
14127
14128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14130 if (SWIG_arg_fail(1)) SWIG_fail;
14131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14132 if (SWIG_arg_fail(2)) SWIG_fail;
14133 {
14134 PyThreadState* __tstate = wxPyBeginAllowThreads();
14135 (arg1)->SetPreviousHandler(arg2);
14136
14137 wxPyEndAllowThreads(__tstate);
14138 if (PyErr_Occurred()) SWIG_fail;
14139 }
14140 Py_INCREF(Py_None); resultobj = Py_None;
14141 return resultobj;
14142 fail:
14143 return NULL;
14144 }
14145
14146
14147 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14148 PyObject *resultobj;
14149 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14150 bool result;
14151 PyObject * obj0 = 0 ;
14152 char *kwnames[] = {
14153 (char *) "self", NULL
14154 };
14155
14156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14158 if (SWIG_arg_fail(1)) SWIG_fail;
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 result = (bool)(arg1)->GetEvtHandlerEnabled();
14162
14163 wxPyEndAllowThreads(__tstate);
14164 if (PyErr_Occurred()) SWIG_fail;
14165 }
14166 {
14167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14168 }
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14176 PyObject *resultobj;
14177 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14178 bool arg2 ;
14179 PyObject * obj0 = 0 ;
14180 PyObject * obj1 = 0 ;
14181 char *kwnames[] = {
14182 (char *) "self",(char *) "enabled", NULL
14183 };
14184
14185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14187 if (SWIG_arg_fail(1)) SWIG_fail;
14188 {
14189 arg2 = (bool)(SWIG_As_bool(obj1));
14190 if (SWIG_arg_fail(2)) SWIG_fail;
14191 }
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 (arg1)->SetEvtHandlerEnabled(arg2);
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 Py_INCREF(Py_None); resultobj = Py_None;
14200 return resultobj;
14201 fail:
14202 return NULL;
14203 }
14204
14205
14206 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14207 PyObject *resultobj;
14208 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14209 wxEvent *arg2 = 0 ;
14210 bool result;
14211 PyObject * obj0 = 0 ;
14212 PyObject * obj1 = 0 ;
14213 char *kwnames[] = {
14214 (char *) "self",(char *) "event", NULL
14215 };
14216
14217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14219 if (SWIG_arg_fail(1)) SWIG_fail;
14220 {
14221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14222 if (SWIG_arg_fail(2)) SWIG_fail;
14223 if (arg2 == NULL) {
14224 SWIG_null_ref("wxEvent");
14225 }
14226 if (SWIG_arg_fail(2)) SWIG_fail;
14227 }
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (bool)(arg1)->ProcessEvent(*arg2);
14231
14232 wxPyEndAllowThreads(__tstate);
14233 if (PyErr_Occurred()) SWIG_fail;
14234 }
14235 {
14236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14237 }
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj;
14246 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14247 wxEvent *arg2 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 char *kwnames[] = {
14251 (char *) "self",(char *) "event", NULL
14252 };
14253
14254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14256 if (SWIG_arg_fail(1)) SWIG_fail;
14257 {
14258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14259 if (SWIG_arg_fail(2)) SWIG_fail;
14260 if (arg2 == NULL) {
14261 SWIG_null_ref("wxEvent");
14262 }
14263 if (SWIG_arg_fail(2)) SWIG_fail;
14264 }
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 (arg1)->AddPendingEvent(*arg2);
14268
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 Py_INCREF(Py_None); resultobj = Py_None;
14273 return resultobj;
14274 fail:
14275 return NULL;
14276 }
14277
14278
14279 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14280 PyObject *resultobj;
14281 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14282 PyObject * obj0 = 0 ;
14283 char *kwnames[] = {
14284 (char *) "self", NULL
14285 };
14286
14287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14289 if (SWIG_arg_fail(1)) SWIG_fail;
14290 {
14291 PyThreadState* __tstate = wxPyBeginAllowThreads();
14292 (arg1)->ProcessPendingEvents();
14293
14294 wxPyEndAllowThreads(__tstate);
14295 if (PyErr_Occurred()) SWIG_fail;
14296 }
14297 Py_INCREF(Py_None); resultobj = Py_None;
14298 return resultobj;
14299 fail:
14300 return NULL;
14301 }
14302
14303
14304 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14305 PyObject *resultobj;
14306 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14307 int arg2 ;
14308 int arg3 ;
14309 int arg4 ;
14310 PyObject *arg5 = (PyObject *) 0 ;
14311 PyObject * obj0 = 0 ;
14312 PyObject * obj1 = 0 ;
14313 PyObject * obj2 = 0 ;
14314 PyObject * obj3 = 0 ;
14315 PyObject * obj4 = 0 ;
14316 char *kwnames[] = {
14317 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14318 };
14319
14320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14322 if (SWIG_arg_fail(1)) SWIG_fail;
14323 {
14324 arg2 = (int)(SWIG_As_int(obj1));
14325 if (SWIG_arg_fail(2)) SWIG_fail;
14326 }
14327 {
14328 arg3 = (int)(SWIG_As_int(obj2));
14329 if (SWIG_arg_fail(3)) SWIG_fail;
14330 }
14331 {
14332 arg4 = (int)(SWIG_As_int(obj3));
14333 if (SWIG_arg_fail(4)) SWIG_fail;
14334 }
14335 arg5 = obj4;
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14339
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 Py_INCREF(Py_None); resultobj = Py_None;
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj;
14352 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14353 int arg2 ;
14354 int arg3 = (int) -1 ;
14355 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14356 bool result;
14357 PyObject * obj0 = 0 ;
14358 PyObject * obj1 = 0 ;
14359 PyObject * obj2 = 0 ;
14360 PyObject * obj3 = 0 ;
14361 char *kwnames[] = {
14362 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14367 if (SWIG_arg_fail(1)) SWIG_fail;
14368 {
14369 arg2 = (int)(SWIG_As_int(obj1));
14370 if (SWIG_arg_fail(2)) SWIG_fail;
14371 }
14372 if (obj2) {
14373 {
14374 arg3 = (int)(SWIG_As_int(obj2));
14375 if (SWIG_arg_fail(3)) SWIG_fail;
14376 }
14377 }
14378 if (obj3) {
14379 {
14380 arg4 = (wxEventType)(SWIG_As_int(obj3));
14381 if (SWIG_arg_fail(4)) SWIG_fail;
14382 }
14383 }
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14387
14388 wxPyEndAllowThreads(__tstate);
14389 if (PyErr_Occurred()) SWIG_fail;
14390 }
14391 {
14392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14393 }
14394 return resultobj;
14395 fail:
14396 return NULL;
14397 }
14398
14399
14400 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14401 PyObject *resultobj;
14402 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14403 PyObject *arg2 = (PyObject *) 0 ;
14404 bool arg3 = (bool) true ;
14405 PyObject * obj0 = 0 ;
14406 PyObject * obj1 = 0 ;
14407 PyObject * obj2 = 0 ;
14408 char *kwnames[] = {
14409 (char *) "self",(char *) "_self",(char *) "incref", NULL
14410 };
14411
14412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14414 if (SWIG_arg_fail(1)) SWIG_fail;
14415 arg2 = obj1;
14416 if (obj2) {
14417 {
14418 arg3 = (bool)(SWIG_As_bool(obj2));
14419 if (SWIG_arg_fail(3)) SWIG_fail;
14420 }
14421 }
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14425
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 Py_INCREF(Py_None); resultobj = Py_None;
14430 return resultobj;
14431 fail:
14432 return NULL;
14433 }
14434
14435
14436 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14437 PyObject *obj;
14438 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14439 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14440 Py_INCREF(obj);
14441 return Py_BuildValue((char *)"");
14442 }
14443 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14444 PyObject *resultobj;
14445 wxEventType result;
14446 char *kwnames[] = {
14447 NULL
14448 };
14449
14450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14451 {
14452 PyThreadState* __tstate = wxPyBeginAllowThreads();
14453 result = (wxEventType)wxNewEventType();
14454
14455 wxPyEndAllowThreads(__tstate);
14456 if (PyErr_Occurred()) SWIG_fail;
14457 }
14458 {
14459 resultobj = SWIG_From_int((int)(result));
14460 }
14461 return resultobj;
14462 fail:
14463 return NULL;
14464 }
14465
14466
14467 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14468 PyObject *resultobj;
14469 wxEvent *arg1 = (wxEvent *) 0 ;
14470 PyObject * obj0 = 0 ;
14471 char *kwnames[] = {
14472 (char *) "self", NULL
14473 };
14474
14475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) 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 {
14479 PyThreadState* __tstate = wxPyBeginAllowThreads();
14480 delete arg1;
14481
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 Py_INCREF(Py_None); resultobj = Py_None;
14486 return resultobj;
14487 fail:
14488 return NULL;
14489 }
14490
14491
14492 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14493 PyObject *resultobj;
14494 wxEvent *arg1 = (wxEvent *) 0 ;
14495 wxEventType arg2 ;
14496 PyObject * obj0 = 0 ;
14497 PyObject * obj1 = 0 ;
14498 char *kwnames[] = {
14499 (char *) "self",(char *) "typ", NULL
14500 };
14501
14502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14504 if (SWIG_arg_fail(1)) SWIG_fail;
14505 {
14506 arg2 = (wxEventType)(SWIG_As_int(obj1));
14507 if (SWIG_arg_fail(2)) SWIG_fail;
14508 }
14509 {
14510 PyThreadState* __tstate = wxPyBeginAllowThreads();
14511 (arg1)->SetEventType(arg2);
14512
14513 wxPyEndAllowThreads(__tstate);
14514 if (PyErr_Occurred()) SWIG_fail;
14515 }
14516 Py_INCREF(Py_None); resultobj = Py_None;
14517 return resultobj;
14518 fail:
14519 return NULL;
14520 }
14521
14522
14523 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14524 PyObject *resultobj;
14525 wxEvent *arg1 = (wxEvent *) 0 ;
14526 wxEventType result;
14527 PyObject * obj0 = 0 ;
14528 char *kwnames[] = {
14529 (char *) "self", NULL
14530 };
14531
14532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14534 if (SWIG_arg_fail(1)) SWIG_fail;
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14538
14539 wxPyEndAllowThreads(__tstate);
14540 if (PyErr_Occurred()) SWIG_fail;
14541 }
14542 {
14543 resultobj = SWIG_From_int((int)(result));
14544 }
14545 return resultobj;
14546 fail:
14547 return NULL;
14548 }
14549
14550
14551 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14552 PyObject *resultobj;
14553 wxEvent *arg1 = (wxEvent *) 0 ;
14554 wxObject *result;
14555 PyObject * obj0 = 0 ;
14556 char *kwnames[] = {
14557 (char *) "self", NULL
14558 };
14559
14560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14566
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 {
14571 resultobj = wxPyMake_wxObject(result, 0);
14572 }
14573 return resultobj;
14574 fail:
14575 return NULL;
14576 }
14577
14578
14579 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14580 PyObject *resultobj;
14581 wxEvent *arg1 = (wxEvent *) 0 ;
14582 wxObject *arg2 = (wxObject *) 0 ;
14583 PyObject * obj0 = 0 ;
14584 PyObject * obj1 = 0 ;
14585 char *kwnames[] = {
14586 (char *) "self",(char *) "obj", NULL
14587 };
14588
14589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14591 if (SWIG_arg_fail(1)) SWIG_fail;
14592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14593 if (SWIG_arg_fail(2)) SWIG_fail;
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 (arg1)->SetEventObject(arg2);
14597
14598 wxPyEndAllowThreads(__tstate);
14599 if (PyErr_Occurred()) SWIG_fail;
14600 }
14601 Py_INCREF(Py_None); resultobj = Py_None;
14602 return resultobj;
14603 fail:
14604 return NULL;
14605 }
14606
14607
14608 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14609 PyObject *resultobj;
14610 wxEvent *arg1 = (wxEvent *) 0 ;
14611 long result;
14612 PyObject * obj0 = 0 ;
14613 char *kwnames[] = {
14614 (char *) "self", NULL
14615 };
14616
14617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14619 if (SWIG_arg_fail(1)) SWIG_fail;
14620 {
14621 PyThreadState* __tstate = wxPyBeginAllowThreads();
14622 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14623
14624 wxPyEndAllowThreads(__tstate);
14625 if (PyErr_Occurred()) SWIG_fail;
14626 }
14627 {
14628 resultobj = SWIG_From_long((long)(result));
14629 }
14630 return resultobj;
14631 fail:
14632 return NULL;
14633 }
14634
14635
14636 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14637 PyObject *resultobj;
14638 wxEvent *arg1 = (wxEvent *) 0 ;
14639 long arg2 = (long) 0 ;
14640 PyObject * obj0 = 0 ;
14641 PyObject * obj1 = 0 ;
14642 char *kwnames[] = {
14643 (char *) "self",(char *) "ts", NULL
14644 };
14645
14646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14648 if (SWIG_arg_fail(1)) SWIG_fail;
14649 if (obj1) {
14650 {
14651 arg2 = (long)(SWIG_As_long(obj1));
14652 if (SWIG_arg_fail(2)) SWIG_fail;
14653 }
14654 }
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 (arg1)->SetTimestamp(arg2);
14658
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 Py_INCREF(Py_None); resultobj = Py_None;
14663 return resultobj;
14664 fail:
14665 return NULL;
14666 }
14667
14668
14669 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14670 PyObject *resultobj;
14671 wxEvent *arg1 = (wxEvent *) 0 ;
14672 int result;
14673 PyObject * obj0 = 0 ;
14674 char *kwnames[] = {
14675 (char *) "self", NULL
14676 };
14677
14678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14680 if (SWIG_arg_fail(1)) SWIG_fail;
14681 {
14682 PyThreadState* __tstate = wxPyBeginAllowThreads();
14683 result = (int)((wxEvent const *)arg1)->GetId();
14684
14685 wxPyEndAllowThreads(__tstate);
14686 if (PyErr_Occurred()) SWIG_fail;
14687 }
14688 {
14689 resultobj = SWIG_From_int((int)(result));
14690 }
14691 return resultobj;
14692 fail:
14693 return NULL;
14694 }
14695
14696
14697 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14698 PyObject *resultobj;
14699 wxEvent *arg1 = (wxEvent *) 0 ;
14700 int arg2 ;
14701 PyObject * obj0 = 0 ;
14702 PyObject * obj1 = 0 ;
14703 char *kwnames[] = {
14704 (char *) "self",(char *) "Id", NULL
14705 };
14706
14707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14709 if (SWIG_arg_fail(1)) SWIG_fail;
14710 {
14711 arg2 = (int)(SWIG_As_int(obj1));
14712 if (SWIG_arg_fail(2)) SWIG_fail;
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 (arg1)->SetId(arg2);
14717
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 Py_INCREF(Py_None); resultobj = Py_None;
14722 return resultobj;
14723 fail:
14724 return NULL;
14725 }
14726
14727
14728 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14729 PyObject *resultobj;
14730 wxEvent *arg1 = (wxEvent *) 0 ;
14731 bool result;
14732 PyObject * obj0 = 0 ;
14733 char *kwnames[] = {
14734 (char *) "self", NULL
14735 };
14736
14737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14739 if (SWIG_arg_fail(1)) SWIG_fail;
14740 {
14741 PyThreadState* __tstate = wxPyBeginAllowThreads();
14742 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14743
14744 wxPyEndAllowThreads(__tstate);
14745 if (PyErr_Occurred()) SWIG_fail;
14746 }
14747 {
14748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14749 }
14750 return resultobj;
14751 fail:
14752 return NULL;
14753 }
14754
14755
14756 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj;
14758 wxEvent *arg1 = (wxEvent *) 0 ;
14759 bool arg2 = (bool) true ;
14760 PyObject * obj0 = 0 ;
14761 PyObject * obj1 = 0 ;
14762 char *kwnames[] = {
14763 (char *) "self",(char *) "skip", NULL
14764 };
14765
14766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14768 if (SWIG_arg_fail(1)) SWIG_fail;
14769 if (obj1) {
14770 {
14771 arg2 = (bool)(SWIG_As_bool(obj1));
14772 if (SWIG_arg_fail(2)) SWIG_fail;
14773 }
14774 }
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 (arg1)->Skip(arg2);
14778
14779 wxPyEndAllowThreads(__tstate);
14780 if (PyErr_Occurred()) SWIG_fail;
14781 }
14782 Py_INCREF(Py_None); resultobj = Py_None;
14783 return resultobj;
14784 fail:
14785 return NULL;
14786 }
14787
14788
14789 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14790 PyObject *resultobj;
14791 wxEvent *arg1 = (wxEvent *) 0 ;
14792 bool result;
14793 PyObject * obj0 = 0 ;
14794 char *kwnames[] = {
14795 (char *) "self", NULL
14796 };
14797
14798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14800 if (SWIG_arg_fail(1)) SWIG_fail;
14801 {
14802 PyThreadState* __tstate = wxPyBeginAllowThreads();
14803 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14804
14805 wxPyEndAllowThreads(__tstate);
14806 if (PyErr_Occurred()) SWIG_fail;
14807 }
14808 {
14809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14810 }
14811 return resultobj;
14812 fail:
14813 return NULL;
14814 }
14815
14816
14817 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14818 PyObject *resultobj;
14819 wxEvent *arg1 = (wxEvent *) 0 ;
14820 bool result;
14821 PyObject * obj0 = 0 ;
14822 char *kwnames[] = {
14823 (char *) "self", NULL
14824 };
14825
14826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14828 if (SWIG_arg_fail(1)) SWIG_fail;
14829 {
14830 PyThreadState* __tstate = wxPyBeginAllowThreads();
14831 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14832
14833 wxPyEndAllowThreads(__tstate);
14834 if (PyErr_Occurred()) SWIG_fail;
14835 }
14836 {
14837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14838 }
14839 return resultobj;
14840 fail:
14841 return NULL;
14842 }
14843
14844
14845 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14846 PyObject *resultobj;
14847 wxEvent *arg1 = (wxEvent *) 0 ;
14848 int result;
14849 PyObject * obj0 = 0 ;
14850 char *kwnames[] = {
14851 (char *) "self", NULL
14852 };
14853
14854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14856 if (SWIG_arg_fail(1)) SWIG_fail;
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 result = (int)(arg1)->StopPropagation();
14860
14861 wxPyEndAllowThreads(__tstate);
14862 if (PyErr_Occurred()) SWIG_fail;
14863 }
14864 {
14865 resultobj = SWIG_From_int((int)(result));
14866 }
14867 return resultobj;
14868 fail:
14869 return NULL;
14870 }
14871
14872
14873 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14874 PyObject *resultobj;
14875 wxEvent *arg1 = (wxEvent *) 0 ;
14876 int arg2 ;
14877 PyObject * obj0 = 0 ;
14878 PyObject * obj1 = 0 ;
14879 char *kwnames[] = {
14880 (char *) "self",(char *) "propagationLevel", NULL
14881 };
14882
14883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14885 if (SWIG_arg_fail(1)) SWIG_fail;
14886 {
14887 arg2 = (int)(SWIG_As_int(obj1));
14888 if (SWIG_arg_fail(2)) SWIG_fail;
14889 }
14890 {
14891 PyThreadState* __tstate = wxPyBeginAllowThreads();
14892 (arg1)->ResumePropagation(arg2);
14893
14894 wxPyEndAllowThreads(__tstate);
14895 if (PyErr_Occurred()) SWIG_fail;
14896 }
14897 Py_INCREF(Py_None); resultobj = Py_None;
14898 return resultobj;
14899 fail:
14900 return NULL;
14901 }
14902
14903
14904 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14905 PyObject *resultobj;
14906 wxEvent *arg1 = (wxEvent *) 0 ;
14907 wxEvent *result;
14908 PyObject * obj0 = 0 ;
14909 char *kwnames[] = {
14910 (char *) "self", NULL
14911 };
14912
14913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14915 if (SWIG_arg_fail(1)) SWIG_fail;
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (wxEvent *)(arg1)->Clone();
14919
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14931 PyObject *obj;
14932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14933 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14934 Py_INCREF(obj);
14935 return Py_BuildValue((char *)"");
14936 }
14937 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14938 PyObject *resultobj;
14939 wxEvent *arg1 = 0 ;
14940 wxPropagationDisabler *result;
14941 PyObject * obj0 = 0 ;
14942 char *kwnames[] = {
14943 (char *) "event", NULL
14944 };
14945
14946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14947 {
14948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14949 if (SWIG_arg_fail(1)) SWIG_fail;
14950 if (arg1 == NULL) {
14951 SWIG_null_ref("wxEvent");
14952 }
14953 if (SWIG_arg_fail(1)) SWIG_fail;
14954 }
14955 {
14956 PyThreadState* __tstate = wxPyBeginAllowThreads();
14957 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14958
14959 wxPyEndAllowThreads(__tstate);
14960 if (PyErr_Occurred()) SWIG_fail;
14961 }
14962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14970 PyObject *resultobj;
14971 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14972 PyObject * obj0 = 0 ;
14973 char *kwnames[] = {
14974 (char *) "self", NULL
14975 };
14976
14977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14979 if (SWIG_arg_fail(1)) SWIG_fail;
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 delete arg1;
14983
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 Py_INCREF(Py_None); resultobj = Py_None;
14988 return resultobj;
14989 fail:
14990 return NULL;
14991 }
14992
14993
14994 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14995 PyObject *obj;
14996 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14997 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14998 Py_INCREF(obj);
14999 return Py_BuildValue((char *)"");
15000 }
15001 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj;
15003 wxEvent *arg1 = 0 ;
15004 wxPropagateOnce *result;
15005 PyObject * obj0 = 0 ;
15006 char *kwnames[] = {
15007 (char *) "event", NULL
15008 };
15009
15010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15011 {
15012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15013 if (SWIG_arg_fail(1)) SWIG_fail;
15014 if (arg1 == NULL) {
15015 SWIG_null_ref("wxEvent");
15016 }
15017 if (SWIG_arg_fail(1)) SWIG_fail;
15018 }
15019 {
15020 PyThreadState* __tstate = wxPyBeginAllowThreads();
15021 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15022
15023 wxPyEndAllowThreads(__tstate);
15024 if (PyErr_Occurred()) SWIG_fail;
15025 }
15026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj;
15035 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15036 PyObject * obj0 = 0 ;
15037 char *kwnames[] = {
15038 (char *) "self", NULL
15039 };
15040
15041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15043 if (SWIG_arg_fail(1)) SWIG_fail;
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 delete arg1;
15047
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 Py_INCREF(Py_None); resultobj = Py_None;
15052 return resultobj;
15053 fail:
15054 return NULL;
15055 }
15056
15057
15058 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15059 PyObject *obj;
15060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15061 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15062 Py_INCREF(obj);
15063 return Py_BuildValue((char *)"");
15064 }
15065 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj;
15067 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15068 int arg2 = (int) 0 ;
15069 wxCommandEvent *result;
15070 PyObject * obj0 = 0 ;
15071 PyObject * obj1 = 0 ;
15072 char *kwnames[] = {
15073 (char *) "commandType",(char *) "winid", NULL
15074 };
15075
15076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15077 if (obj0) {
15078 {
15079 arg1 = (wxEventType)(SWIG_As_int(obj0));
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 }
15082 }
15083 if (obj1) {
15084 {
15085 arg2 = (int)(SWIG_As_int(obj1));
15086 if (SWIG_arg_fail(2)) SWIG_fail;
15087 }
15088 }
15089 {
15090 PyThreadState* __tstate = wxPyBeginAllowThreads();
15091 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15092
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15097 return resultobj;
15098 fail:
15099 return NULL;
15100 }
15101
15102
15103 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15104 PyObject *resultobj;
15105 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15106 int result;
15107 PyObject * obj0 = 0 ;
15108 char *kwnames[] = {
15109 (char *) "self", NULL
15110 };
15111
15112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15114 if (SWIG_arg_fail(1)) SWIG_fail;
15115 {
15116 PyThreadState* __tstate = wxPyBeginAllowThreads();
15117 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15118
15119 wxPyEndAllowThreads(__tstate);
15120 if (PyErr_Occurred()) SWIG_fail;
15121 }
15122 {
15123 resultobj = SWIG_From_int((int)(result));
15124 }
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15132 PyObject *resultobj;
15133 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15134 wxString *arg2 = 0 ;
15135 bool temp2 = false ;
15136 PyObject * obj0 = 0 ;
15137 PyObject * obj1 = 0 ;
15138 char *kwnames[] = {
15139 (char *) "self",(char *) "s", NULL
15140 };
15141
15142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15144 if (SWIG_arg_fail(1)) SWIG_fail;
15145 {
15146 arg2 = wxString_in_helper(obj1);
15147 if (arg2 == NULL) SWIG_fail;
15148 temp2 = true;
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 (arg1)->SetString((wxString const &)*arg2);
15153
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 Py_INCREF(Py_None); resultobj = Py_None;
15158 {
15159 if (temp2)
15160 delete arg2;
15161 }
15162 return resultobj;
15163 fail:
15164 {
15165 if (temp2)
15166 delete arg2;
15167 }
15168 return NULL;
15169 }
15170
15171
15172 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj;
15174 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15175 wxString result;
15176 PyObject * obj0 = 0 ;
15177 char *kwnames[] = {
15178 (char *) "self", NULL
15179 };
15180
15181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15183 if (SWIG_arg_fail(1)) SWIG_fail;
15184 {
15185 PyThreadState* __tstate = wxPyBeginAllowThreads();
15186 result = ((wxCommandEvent const *)arg1)->GetString();
15187
15188 wxPyEndAllowThreads(__tstate);
15189 if (PyErr_Occurred()) SWIG_fail;
15190 }
15191 {
15192 #if wxUSE_UNICODE
15193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15194 #else
15195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15196 #endif
15197 }
15198 return resultobj;
15199 fail:
15200 return NULL;
15201 }
15202
15203
15204 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15205 PyObject *resultobj;
15206 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15207 bool result;
15208 PyObject * obj0 = 0 ;
15209 char *kwnames[] = {
15210 (char *) "self", NULL
15211 };
15212
15213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15215 if (SWIG_arg_fail(1)) SWIG_fail;
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15219
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 {
15224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15225 }
15226 return resultobj;
15227 fail:
15228 return NULL;
15229 }
15230
15231
15232 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15233 PyObject *resultobj;
15234 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15235 bool result;
15236 PyObject * obj0 = 0 ;
15237 char *kwnames[] = {
15238 (char *) "self", NULL
15239 };
15240
15241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15243 if (SWIG_arg_fail(1)) SWIG_fail;
15244 {
15245 PyThreadState* __tstate = wxPyBeginAllowThreads();
15246 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15247
15248 wxPyEndAllowThreads(__tstate);
15249 if (PyErr_Occurred()) SWIG_fail;
15250 }
15251 {
15252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15253 }
15254 return resultobj;
15255 fail:
15256 return NULL;
15257 }
15258
15259
15260 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15261 PyObject *resultobj;
15262 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15263 long arg2 ;
15264 PyObject * obj0 = 0 ;
15265 PyObject * obj1 = 0 ;
15266 char *kwnames[] = {
15267 (char *) "self",(char *) "extraLong", NULL
15268 };
15269
15270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15272 if (SWIG_arg_fail(1)) SWIG_fail;
15273 {
15274 arg2 = (long)(SWIG_As_long(obj1));
15275 if (SWIG_arg_fail(2)) SWIG_fail;
15276 }
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 (arg1)->SetExtraLong(arg2);
15280
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 Py_INCREF(Py_None); resultobj = Py_None;
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15292 PyObject *resultobj;
15293 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15294 long result;
15295 PyObject * obj0 = 0 ;
15296 char *kwnames[] = {
15297 (char *) "self", NULL
15298 };
15299
15300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15302 if (SWIG_arg_fail(1)) SWIG_fail;
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15306
15307 wxPyEndAllowThreads(__tstate);
15308 if (PyErr_Occurred()) SWIG_fail;
15309 }
15310 {
15311 resultobj = SWIG_From_long((long)(result));
15312 }
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj;
15321 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15322 int arg2 ;
15323 PyObject * obj0 = 0 ;
15324 PyObject * obj1 = 0 ;
15325 char *kwnames[] = {
15326 (char *) "self",(char *) "i", NULL
15327 };
15328
15329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15331 if (SWIG_arg_fail(1)) SWIG_fail;
15332 {
15333 arg2 = (int)(SWIG_As_int(obj1));
15334 if (SWIG_arg_fail(2)) SWIG_fail;
15335 }
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 (arg1)->SetInt(arg2);
15339
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 Py_INCREF(Py_None); resultobj = Py_None;
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15351 PyObject *resultobj;
15352 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15353 long result;
15354 PyObject * obj0 = 0 ;
15355 char *kwnames[] = {
15356 (char *) "self", NULL
15357 };
15358
15359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(1)) SWIG_fail;
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15365
15366 wxPyEndAllowThreads(__tstate);
15367 if (PyErr_Occurred()) SWIG_fail;
15368 }
15369 {
15370 resultobj = SWIG_From_long((long)(result));
15371 }
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15379 PyObject *resultobj;
15380 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15381 wxEvent *result;
15382 PyObject * obj0 = 0 ;
15383 char *kwnames[] = {
15384 (char *) "self", NULL
15385 };
15386
15387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15389 if (SWIG_arg_fail(1)) SWIG_fail;
15390 {
15391 PyThreadState* __tstate = wxPyBeginAllowThreads();
15392 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15393
15394 wxPyEndAllowThreads(__tstate);
15395 if (PyErr_Occurred()) SWIG_fail;
15396 }
15397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15405 PyObject *obj;
15406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15407 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15408 Py_INCREF(obj);
15409 return Py_BuildValue((char *)"");
15410 }
15411 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15412 PyObject *resultobj;
15413 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15414 int arg2 = (int) 0 ;
15415 wxNotifyEvent *result;
15416 PyObject * obj0 = 0 ;
15417 PyObject * obj1 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "commandType",(char *) "winid", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15423 if (obj0) {
15424 {
15425 arg1 = (wxEventType)(SWIG_As_int(obj0));
15426 if (SWIG_arg_fail(1)) SWIG_fail;
15427 }
15428 }
15429 if (obj1) {
15430 {
15431 arg2 = (int)(SWIG_As_int(obj1));
15432 if (SWIG_arg_fail(2)) SWIG_fail;
15433 }
15434 }
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15438
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj;
15451 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15452 PyObject * obj0 = 0 ;
15453 char *kwnames[] = {
15454 (char *) "self", NULL
15455 };
15456
15457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15459 if (SWIG_arg_fail(1)) SWIG_fail;
15460 {
15461 PyThreadState* __tstate = wxPyBeginAllowThreads();
15462 (arg1)->Veto();
15463
15464 wxPyEndAllowThreads(__tstate);
15465 if (PyErr_Occurred()) SWIG_fail;
15466 }
15467 Py_INCREF(Py_None); resultobj = Py_None;
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj;
15476 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15477 PyObject * obj0 = 0 ;
15478 char *kwnames[] = {
15479 (char *) "self", NULL
15480 };
15481
15482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15484 if (SWIG_arg_fail(1)) SWIG_fail;
15485 {
15486 PyThreadState* __tstate = wxPyBeginAllowThreads();
15487 (arg1)->Allow();
15488
15489 wxPyEndAllowThreads(__tstate);
15490 if (PyErr_Occurred()) SWIG_fail;
15491 }
15492 Py_INCREF(Py_None); resultobj = Py_None;
15493 return resultobj;
15494 fail:
15495 return NULL;
15496 }
15497
15498
15499 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15500 PyObject *resultobj;
15501 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15502 bool result;
15503 PyObject * obj0 = 0 ;
15504 char *kwnames[] = {
15505 (char *) "self", NULL
15506 };
15507
15508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15510 if (SWIG_arg_fail(1)) SWIG_fail;
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 result = (bool)(arg1)->IsAllowed();
15514
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 {
15519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15520 }
15521 return resultobj;
15522 fail:
15523 return NULL;
15524 }
15525
15526
15527 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15528 PyObject *obj;
15529 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15530 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15531 Py_INCREF(obj);
15532 return Py_BuildValue((char *)"");
15533 }
15534 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15535 PyObject *resultobj;
15536 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15537 int arg2 = (int) 0 ;
15538 int arg3 = (int) 0 ;
15539 int arg4 = (int) 0 ;
15540 wxScrollEvent *result;
15541 PyObject * obj0 = 0 ;
15542 PyObject * obj1 = 0 ;
15543 PyObject * obj2 = 0 ;
15544 PyObject * obj3 = 0 ;
15545 char *kwnames[] = {
15546 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15547 };
15548
15549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15550 if (obj0) {
15551 {
15552 arg1 = (wxEventType)(SWIG_As_int(obj0));
15553 if (SWIG_arg_fail(1)) SWIG_fail;
15554 }
15555 }
15556 if (obj1) {
15557 {
15558 arg2 = (int)(SWIG_As_int(obj1));
15559 if (SWIG_arg_fail(2)) SWIG_fail;
15560 }
15561 }
15562 if (obj2) {
15563 {
15564 arg3 = (int)(SWIG_As_int(obj2));
15565 if (SWIG_arg_fail(3)) SWIG_fail;
15566 }
15567 }
15568 if (obj3) {
15569 {
15570 arg4 = (int)(SWIG_As_int(obj3));
15571 if (SWIG_arg_fail(4)) SWIG_fail;
15572 }
15573 }
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15577
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15589 PyObject *resultobj;
15590 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15599 if (SWIG_arg_fail(1)) SWIG_fail;
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (int)((wxScrollEvent 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_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj;
15618 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15627 if (SWIG_arg_fail(1)) SWIG_fail;
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (int)((wxScrollEvent 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_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj;
15646 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, 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_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15676 PyObject *resultobj;
15677 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, 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 * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15707 PyObject *obj;
15708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15709 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15710 Py_INCREF(obj);
15711 return Py_BuildValue((char *)"");
15712 }
15713 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15714 PyObject *resultobj;
15715 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15716 int arg2 = (int) 0 ;
15717 int arg3 = (int) 0 ;
15718 wxScrollWinEvent *result;
15719 PyObject * obj0 = 0 ;
15720 PyObject * obj1 = 0 ;
15721 PyObject * obj2 = 0 ;
15722 char *kwnames[] = {
15723 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15724 };
15725
15726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15727 if (obj0) {
15728 {
15729 arg1 = (wxEventType)(SWIG_As_int(obj0));
15730 if (SWIG_arg_fail(1)) SWIG_fail;
15731 }
15732 }
15733 if (obj1) {
15734 {
15735 arg2 = (int)(SWIG_As_int(obj1));
15736 if (SWIG_arg_fail(2)) SWIG_fail;
15737 }
15738 }
15739 if (obj2) {
15740 {
15741 arg3 = (int)(SWIG_As_int(obj2));
15742 if (SWIG_arg_fail(3)) SWIG_fail;
15743 }
15744 }
15745 {
15746 PyThreadState* __tstate = wxPyBeginAllowThreads();
15747 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15748
15749 wxPyEndAllowThreads(__tstate);
15750 if (PyErr_Occurred()) SWIG_fail;
15751 }
15752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15753 return resultobj;
15754 fail:
15755 return NULL;
15756 }
15757
15758
15759 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15760 PyObject *resultobj;
15761 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15762 int result;
15763 PyObject * obj0 = 0 ;
15764 char *kwnames[] = {
15765 (char *) "self", NULL
15766 };
15767
15768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15770 if (SWIG_arg_fail(1)) SWIG_fail;
15771 {
15772 PyThreadState* __tstate = wxPyBeginAllowThreads();
15773 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15774
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 {
15779 resultobj = SWIG_From_int((int)(result));
15780 }
15781 return resultobj;
15782 fail:
15783 return NULL;
15784 }
15785
15786
15787 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15788 PyObject *resultobj;
15789 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15790 int result;
15791 PyObject * obj0 = 0 ;
15792 char *kwnames[] = {
15793 (char *) "self", NULL
15794 };
15795
15796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15798 if (SWIG_arg_fail(1)) SWIG_fail;
15799 {
15800 PyThreadState* __tstate = wxPyBeginAllowThreads();
15801 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15802
15803 wxPyEndAllowThreads(__tstate);
15804 if (PyErr_Occurred()) SWIG_fail;
15805 }
15806 {
15807 resultobj = SWIG_From_int((int)(result));
15808 }
15809 return resultobj;
15810 fail:
15811 return NULL;
15812 }
15813
15814
15815 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15816 PyObject *resultobj;
15817 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15818 int arg2 ;
15819 PyObject * obj0 = 0 ;
15820 PyObject * obj1 = 0 ;
15821 char *kwnames[] = {
15822 (char *) "self",(char *) "orient", NULL
15823 };
15824
15825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15827 if (SWIG_arg_fail(1)) SWIG_fail;
15828 {
15829 arg2 = (int)(SWIG_As_int(obj1));
15830 if (SWIG_arg_fail(2)) SWIG_fail;
15831 }
15832 {
15833 PyThreadState* __tstate = wxPyBeginAllowThreads();
15834 (arg1)->SetOrientation(arg2);
15835
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 Py_INCREF(Py_None); resultobj = Py_None;
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj;
15848 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15849 int arg2 ;
15850 PyObject * obj0 = 0 ;
15851 PyObject * obj1 = 0 ;
15852 char *kwnames[] = {
15853 (char *) "self",(char *) "pos", NULL
15854 };
15855
15856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15858 if (SWIG_arg_fail(1)) SWIG_fail;
15859 {
15860 arg2 = (int)(SWIG_As_int(obj1));
15861 if (SWIG_arg_fail(2)) SWIG_fail;
15862 }
15863 {
15864 PyThreadState* __tstate = wxPyBeginAllowThreads();
15865 (arg1)->SetPosition(arg2);
15866
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 Py_INCREF(Py_None); resultobj = Py_None;
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15878 PyObject *obj;
15879 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15880 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15881 Py_INCREF(obj);
15882 return Py_BuildValue((char *)"");
15883 }
15884 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15885 PyObject *resultobj;
15886 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15887 wxMouseEvent *result;
15888 PyObject * obj0 = 0 ;
15889 char *kwnames[] = {
15890 (char *) "mouseType", NULL
15891 };
15892
15893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15894 if (obj0) {
15895 {
15896 arg1 = (wxEventType)(SWIG_As_int(obj0));
15897 if (SWIG_arg_fail(1)) SWIG_fail;
15898 }
15899 }
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15903
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 {
15908 resultobj = wxPyMake_wxObject(result, 1);
15909 }
15910 return resultobj;
15911 fail:
15912 return NULL;
15913 }
15914
15915
15916 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15917 PyObject *resultobj;
15918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15919 bool result;
15920 PyObject * obj0 = 0 ;
15921 char *kwnames[] = {
15922 (char *) "self", NULL
15923 };
15924
15925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15927 if (SWIG_arg_fail(1)) SWIG_fail;
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15931
15932 wxPyEndAllowThreads(__tstate);
15933 if (PyErr_Occurred()) SWIG_fail;
15934 }
15935 {
15936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15937 }
15938 return resultobj;
15939 fail:
15940 return NULL;
15941 }
15942
15943
15944 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15945 PyObject *resultobj;
15946 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15947 int arg2 = (int) wxMOUSE_BTN_ANY ;
15948 bool result;
15949 PyObject * obj0 = 0 ;
15950 PyObject * obj1 = 0 ;
15951 char *kwnames[] = {
15952 (char *) "self",(char *) "but", NULL
15953 };
15954
15955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15957 if (SWIG_arg_fail(1)) SWIG_fail;
15958 if (obj1) {
15959 {
15960 arg2 = (int)(SWIG_As_int(obj1));
15961 if (SWIG_arg_fail(2)) SWIG_fail;
15962 }
15963 }
15964 {
15965 PyThreadState* __tstate = wxPyBeginAllowThreads();
15966 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15967
15968 wxPyEndAllowThreads(__tstate);
15969 if (PyErr_Occurred()) SWIG_fail;
15970 }
15971 {
15972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15973 }
15974 return resultobj;
15975 fail:
15976 return NULL;
15977 }
15978
15979
15980 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15981 PyObject *resultobj;
15982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15983 int arg2 = (int) wxMOUSE_BTN_ANY ;
15984 bool result;
15985 PyObject * obj0 = 0 ;
15986 PyObject * obj1 = 0 ;
15987 char *kwnames[] = {
15988 (char *) "self",(char *) "but", NULL
15989 };
15990
15991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15993 if (SWIG_arg_fail(1)) SWIG_fail;
15994 if (obj1) {
15995 {
15996 arg2 = (int)(SWIG_As_int(obj1));
15997 if (SWIG_arg_fail(2)) SWIG_fail;
15998 }
15999 }
16000 {
16001 PyThreadState* __tstate = wxPyBeginAllowThreads();
16002 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16003
16004 wxPyEndAllowThreads(__tstate);
16005 if (PyErr_Occurred()) SWIG_fail;
16006 }
16007 {
16008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16009 }
16010 return resultobj;
16011 fail:
16012 return NULL;
16013 }
16014
16015
16016 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16017 PyObject *resultobj;
16018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16019 int arg2 = (int) wxMOUSE_BTN_ANY ;
16020 bool result;
16021 PyObject * obj0 = 0 ;
16022 PyObject * obj1 = 0 ;
16023 char *kwnames[] = {
16024 (char *) "self",(char *) "but", NULL
16025 };
16026
16027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16029 if (SWIG_arg_fail(1)) SWIG_fail;
16030 if (obj1) {
16031 {
16032 arg2 = (int)(SWIG_As_int(obj1));
16033 if (SWIG_arg_fail(2)) SWIG_fail;
16034 }
16035 }
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16039
16040 wxPyEndAllowThreads(__tstate);
16041 if (PyErr_Occurred()) SWIG_fail;
16042 }
16043 {
16044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16045 }
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj;
16054 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16055 int arg2 ;
16056 bool result;
16057 PyObject * obj0 = 0 ;
16058 PyObject * obj1 = 0 ;
16059 char *kwnames[] = {
16060 (char *) "self",(char *) "but", NULL
16061 };
16062
16063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16065 if (SWIG_arg_fail(1)) SWIG_fail;
16066 {
16067 arg2 = (int)(SWIG_As_int(obj1));
16068 if (SWIG_arg_fail(2)) SWIG_fail;
16069 }
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16073
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 {
16078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16079 }
16080 return resultobj;
16081 fail:
16082 return NULL;
16083 }
16084
16085
16086 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16087 PyObject *resultobj;
16088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16089 int arg2 ;
16090 bool result;
16091 PyObject * obj0 = 0 ;
16092 PyObject * obj1 = 0 ;
16093 char *kwnames[] = {
16094 (char *) "self",(char *) "but", NULL
16095 };
16096
16097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16099 if (SWIG_arg_fail(1)) SWIG_fail;
16100 {
16101 arg2 = (int)(SWIG_As_int(obj1));
16102 if (SWIG_arg_fail(2)) SWIG_fail;
16103 }
16104 {
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16107
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 {
16112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16113 }
16114 return resultobj;
16115 fail:
16116 return NULL;
16117 }
16118
16119
16120 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16121 PyObject *resultobj;
16122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16123 int result;
16124 PyObject * obj0 = 0 ;
16125 char *kwnames[] = {
16126 (char *) "self", NULL
16127 };
16128
16129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16131 if (SWIG_arg_fail(1)) SWIG_fail;
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16135
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 {
16140 resultobj = SWIG_From_int((int)(result));
16141 }
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16149 PyObject *resultobj;
16150 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16151 bool result;
16152 PyObject * obj0 = 0 ;
16153 char *kwnames[] = {
16154 (char *) "self", NULL
16155 };
16156
16157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16159 if (SWIG_arg_fail(1)) SWIG_fail;
16160 {
16161 PyThreadState* __tstate = wxPyBeginAllowThreads();
16162 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16163
16164 wxPyEndAllowThreads(__tstate);
16165 if (PyErr_Occurred()) SWIG_fail;
16166 }
16167 {
16168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16169 }
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16177 PyObject *resultobj;
16178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16179 bool result;
16180 PyObject * obj0 = 0 ;
16181 char *kwnames[] = {
16182 (char *) "self", NULL
16183 };
16184
16185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16187 if (SWIG_arg_fail(1)) SWIG_fail;
16188 {
16189 PyThreadState* __tstate = wxPyBeginAllowThreads();
16190 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16191
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 {
16196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16197 }
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj;
16206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16207 bool result;
16208 PyObject * obj0 = 0 ;
16209 char *kwnames[] = {
16210 (char *) "self", NULL
16211 };
16212
16213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16215 if (SWIG_arg_fail(1)) SWIG_fail;
16216 {
16217 PyThreadState* __tstate = wxPyBeginAllowThreads();
16218 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16219
16220 wxPyEndAllowThreads(__tstate);
16221 if (PyErr_Occurred()) SWIG_fail;
16222 }
16223 {
16224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16225 }
16226 return resultobj;
16227 fail:
16228 return NULL;
16229 }
16230
16231
16232 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16233 PyObject *resultobj;
16234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16235 bool result;
16236 PyObject * obj0 = 0 ;
16237 char *kwnames[] = {
16238 (char *) "self", NULL
16239 };
16240
16241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16243 if (SWIG_arg_fail(1)) SWIG_fail;
16244 {
16245 PyThreadState* __tstate = wxPyBeginAllowThreads();
16246 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16247
16248 wxPyEndAllowThreads(__tstate);
16249 if (PyErr_Occurred()) SWIG_fail;
16250 }
16251 {
16252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16253 }
16254 return resultobj;
16255 fail:
16256 return NULL;
16257 }
16258
16259
16260 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16261 PyObject *resultobj;
16262 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16263 bool result;
16264 PyObject * obj0 = 0 ;
16265 char *kwnames[] = {
16266 (char *) "self", NULL
16267 };
16268
16269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16271 if (SWIG_arg_fail(1)) SWIG_fail;
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16275
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 {
16280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16281 }
16282 return resultobj;
16283 fail:
16284 return NULL;
16285 }
16286
16287
16288 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16289 PyObject *resultobj;
16290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16291 bool result;
16292 PyObject * obj0 = 0 ;
16293 char *kwnames[] = {
16294 (char *) "self", NULL
16295 };
16296
16297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16299 if (SWIG_arg_fail(1)) SWIG_fail;
16300 {
16301 PyThreadState* __tstate = wxPyBeginAllowThreads();
16302 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16303
16304 wxPyEndAllowThreads(__tstate);
16305 if (PyErr_Occurred()) SWIG_fail;
16306 }
16307 {
16308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16309 }
16310 return resultobj;
16311 fail:
16312 return NULL;
16313 }
16314
16315
16316 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16317 PyObject *resultobj;
16318 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16319 bool result;
16320 PyObject * obj0 = 0 ;
16321 char *kwnames[] = {
16322 (char *) "self", NULL
16323 };
16324
16325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16327 if (SWIG_arg_fail(1)) SWIG_fail;
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16331
16332 wxPyEndAllowThreads(__tstate);
16333 if (PyErr_Occurred()) SWIG_fail;
16334 }
16335 {
16336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16337 }
16338 return resultobj;
16339 fail:
16340 return NULL;
16341 }
16342
16343
16344 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16345 PyObject *resultobj;
16346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16347 bool result;
16348 PyObject * obj0 = 0 ;
16349 char *kwnames[] = {
16350 (char *) "self", NULL
16351 };
16352
16353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16355 if (SWIG_arg_fail(1)) SWIG_fail;
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16359
16360 wxPyEndAllowThreads(__tstate);
16361 if (PyErr_Occurred()) SWIG_fail;
16362 }
16363 {
16364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16365 }
16366 return resultobj;
16367 fail:
16368 return NULL;
16369 }
16370
16371
16372 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj;
16374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16375 bool result;
16376 PyObject * obj0 = 0 ;
16377 char *kwnames[] = {
16378 (char *) "self", NULL
16379 };
16380
16381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16383 if (SWIG_arg_fail(1)) SWIG_fail;
16384 {
16385 PyThreadState* __tstate = wxPyBeginAllowThreads();
16386 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16387
16388 wxPyEndAllowThreads(__tstate);
16389 if (PyErr_Occurred()) SWIG_fail;
16390 }
16391 {
16392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16393 }
16394 return resultobj;
16395 fail:
16396 return NULL;
16397 }
16398
16399
16400 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16401 PyObject *resultobj;
16402 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16403 bool result;
16404 PyObject * obj0 = 0 ;
16405 char *kwnames[] = {
16406 (char *) "self", NULL
16407 };
16408
16409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16411 if (SWIG_arg_fail(1)) SWIG_fail;
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16415
16416 wxPyEndAllowThreads(__tstate);
16417 if (PyErr_Occurred()) SWIG_fail;
16418 }
16419 {
16420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16421 }
16422 return resultobj;
16423 fail:
16424 return NULL;
16425 }
16426
16427
16428 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16429 PyObject *resultobj;
16430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16431 bool result;
16432 PyObject * obj0 = 0 ;
16433 char *kwnames[] = {
16434 (char *) "self", NULL
16435 };
16436
16437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16439 if (SWIG_arg_fail(1)) SWIG_fail;
16440 {
16441 PyThreadState* __tstate = wxPyBeginAllowThreads();
16442 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16443
16444 wxPyEndAllowThreads(__tstate);
16445 if (PyErr_Occurred()) SWIG_fail;
16446 }
16447 {
16448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16449 }
16450 return resultobj;
16451 fail:
16452 return NULL;
16453 }
16454
16455
16456 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16457 PyObject *resultobj;
16458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16459 bool result;
16460 PyObject * obj0 = 0 ;
16461 char *kwnames[] = {
16462 (char *) "self", NULL
16463 };
16464
16465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16467 if (SWIG_arg_fail(1)) SWIG_fail;
16468 {
16469 PyThreadState* __tstate = wxPyBeginAllowThreads();
16470 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16471
16472 wxPyEndAllowThreads(__tstate);
16473 if (PyErr_Occurred()) SWIG_fail;
16474 }
16475 {
16476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16477 }
16478 return resultobj;
16479 fail:
16480 return NULL;
16481 }
16482
16483
16484 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj;
16486 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16487 bool result;
16488 PyObject * obj0 = 0 ;
16489 char *kwnames[] = {
16490 (char *) "self", NULL
16491 };
16492
16493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16495 if (SWIG_arg_fail(1)) SWIG_fail;
16496 {
16497 PyThreadState* __tstate = wxPyBeginAllowThreads();
16498 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16499
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 {
16504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16505 }
16506 return resultobj;
16507 fail:
16508 return NULL;
16509 }
16510
16511
16512 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16513 PyObject *resultobj;
16514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16515 bool result;
16516 PyObject * obj0 = 0 ;
16517 char *kwnames[] = {
16518 (char *) "self", NULL
16519 };
16520
16521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16523 if (SWIG_arg_fail(1)) SWIG_fail;
16524 {
16525 PyThreadState* __tstate = wxPyBeginAllowThreads();
16526 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16527
16528 wxPyEndAllowThreads(__tstate);
16529 if (PyErr_Occurred()) SWIG_fail;
16530 }
16531 {
16532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16533 }
16534 return resultobj;
16535 fail:
16536 return NULL;
16537 }
16538
16539
16540 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16541 PyObject *resultobj;
16542 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16543 bool result;
16544 PyObject * obj0 = 0 ;
16545 char *kwnames[] = {
16546 (char *) "self", NULL
16547 };
16548
16549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16551 if (SWIG_arg_fail(1)) SWIG_fail;
16552 {
16553 PyThreadState* __tstate = wxPyBeginAllowThreads();
16554 result = (bool)(arg1)->LeftIsDown();
16555
16556 wxPyEndAllowThreads(__tstate);
16557 if (PyErr_Occurred()) SWIG_fail;
16558 }
16559 {
16560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16561 }
16562 return resultobj;
16563 fail:
16564 return NULL;
16565 }
16566
16567
16568 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj;
16570 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16571 bool result;
16572 PyObject * obj0 = 0 ;
16573 char *kwnames[] = {
16574 (char *) "self", NULL
16575 };
16576
16577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16579 if (SWIG_arg_fail(1)) SWIG_fail;
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 result = (bool)(arg1)->MiddleIsDown();
16583
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 {
16588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16589 }
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj;
16598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16599 bool result;
16600 PyObject * obj0 = 0 ;
16601 char *kwnames[] = {
16602 (char *) "self", NULL
16603 };
16604
16605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16607 if (SWIG_arg_fail(1)) SWIG_fail;
16608 {
16609 PyThreadState* __tstate = wxPyBeginAllowThreads();
16610 result = (bool)(arg1)->RightIsDown();
16611
16612 wxPyEndAllowThreads(__tstate);
16613 if (PyErr_Occurred()) SWIG_fail;
16614 }
16615 {
16616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16617 }
16618 return resultobj;
16619 fail:
16620 return NULL;
16621 }
16622
16623
16624 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16625 PyObject *resultobj;
16626 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16627 bool result;
16628 PyObject * obj0 = 0 ;
16629 char *kwnames[] = {
16630 (char *) "self", NULL
16631 };
16632
16633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16635 if (SWIG_arg_fail(1)) SWIG_fail;
16636 {
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16639
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 {
16644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16645 }
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj;
16654 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16655 bool result;
16656 PyObject * obj0 = 0 ;
16657 char *kwnames[] = {
16658 (char *) "self", NULL
16659 };
16660
16661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16663 if (SWIG_arg_fail(1)) SWIG_fail;
16664 {
16665 PyThreadState* __tstate = wxPyBeginAllowThreads();
16666 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16667
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 {
16672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16673 }
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16681 PyObject *resultobj;
16682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16683 bool result;
16684 PyObject * obj0 = 0 ;
16685 char *kwnames[] = {
16686 (char *) "self", NULL
16687 };
16688
16689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16691 if (SWIG_arg_fail(1)) SWIG_fail;
16692 {
16693 PyThreadState* __tstate = wxPyBeginAllowThreads();
16694 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16695
16696 wxPyEndAllowThreads(__tstate);
16697 if (PyErr_Occurred()) SWIG_fail;
16698 }
16699 {
16700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16701 }
16702 return resultobj;
16703 fail:
16704 return NULL;
16705 }
16706
16707
16708 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16709 PyObject *resultobj;
16710 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16711 bool result;
16712 PyObject * obj0 = 0 ;
16713 char *kwnames[] = {
16714 (char *) "self", NULL
16715 };
16716
16717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16719 if (SWIG_arg_fail(1)) SWIG_fail;
16720 {
16721 PyThreadState* __tstate = wxPyBeginAllowThreads();
16722 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16723
16724 wxPyEndAllowThreads(__tstate);
16725 if (PyErr_Occurred()) SWIG_fail;
16726 }
16727 {
16728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16729 }
16730 return resultobj;
16731 fail:
16732 return NULL;
16733 }
16734
16735
16736 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16737 PyObject *resultobj;
16738 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16739 wxPoint result;
16740 PyObject * obj0 = 0 ;
16741 char *kwnames[] = {
16742 (char *) "self", NULL
16743 };
16744
16745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16747 if (SWIG_arg_fail(1)) SWIG_fail;
16748 {
16749 PyThreadState* __tstate = wxPyBeginAllowThreads();
16750 result = (arg1)->GetPosition();
16751
16752 wxPyEndAllowThreads(__tstate);
16753 if (PyErr_Occurred()) SWIG_fail;
16754 }
16755 {
16756 wxPoint * resultptr;
16757 resultptr = new wxPoint((wxPoint &)(result));
16758 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16759 }
16760 return resultobj;
16761 fail:
16762 return NULL;
16763 }
16764
16765
16766 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16767 PyObject *resultobj;
16768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16769 long *arg2 = (long *) 0 ;
16770 long *arg3 = (long *) 0 ;
16771 long temp2 ;
16772 int res2 = 0 ;
16773 long temp3 ;
16774 int res3 = 0 ;
16775 PyObject * obj0 = 0 ;
16776 char *kwnames[] = {
16777 (char *) "self", NULL
16778 };
16779
16780 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16781 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16784 if (SWIG_arg_fail(1)) SWIG_fail;
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 (arg1)->GetPosition(arg2,arg3);
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 Py_INCREF(Py_None); resultobj = Py_None;
16793 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16794 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16795 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16796 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16804 PyObject *resultobj;
16805 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16806 wxDC *arg2 = 0 ;
16807 wxPoint result;
16808 PyObject * obj0 = 0 ;
16809 PyObject * obj1 = 0 ;
16810 char *kwnames[] = {
16811 (char *) "self",(char *) "dc", NULL
16812 };
16813
16814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16816 if (SWIG_arg_fail(1)) SWIG_fail;
16817 {
16818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16819 if (SWIG_arg_fail(2)) SWIG_fail;
16820 if (arg2 == NULL) {
16821 SWIG_null_ref("wxDC");
16822 }
16823 if (SWIG_arg_fail(2)) SWIG_fail;
16824 }
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16828
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 {
16833 wxPoint * resultptr;
16834 resultptr = new wxPoint((wxPoint &)(result));
16835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16836 }
16837 return resultobj;
16838 fail:
16839 return NULL;
16840 }
16841
16842
16843 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16844 PyObject *resultobj;
16845 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16846 int result;
16847 PyObject * obj0 = 0 ;
16848 char *kwnames[] = {
16849 (char *) "self", NULL
16850 };
16851
16852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16854 if (SWIG_arg_fail(1)) SWIG_fail;
16855 {
16856 PyThreadState* __tstate = wxPyBeginAllowThreads();
16857 result = (int)((wxMouseEvent const *)arg1)->GetX();
16858
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 {
16863 resultobj = SWIG_From_int((int)(result));
16864 }
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16872 PyObject *resultobj;
16873 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16874 int result;
16875 PyObject * obj0 = 0 ;
16876 char *kwnames[] = {
16877 (char *) "self", NULL
16878 };
16879
16880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16882 if (SWIG_arg_fail(1)) SWIG_fail;
16883 {
16884 PyThreadState* __tstate = wxPyBeginAllowThreads();
16885 result = (int)((wxMouseEvent const *)arg1)->GetY();
16886
16887 wxPyEndAllowThreads(__tstate);
16888 if (PyErr_Occurred()) SWIG_fail;
16889 }
16890 {
16891 resultobj = SWIG_From_int((int)(result));
16892 }
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16900 PyObject *resultobj;
16901 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16902 int result;
16903 PyObject * obj0 = 0 ;
16904 char *kwnames[] = {
16905 (char *) "self", NULL
16906 };
16907
16908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16910 if (SWIG_arg_fail(1)) SWIG_fail;
16911 {
16912 PyThreadState* __tstate = wxPyBeginAllowThreads();
16913 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16914
16915 wxPyEndAllowThreads(__tstate);
16916 if (PyErr_Occurred()) SWIG_fail;
16917 }
16918 {
16919 resultobj = SWIG_From_int((int)(result));
16920 }
16921 return resultobj;
16922 fail:
16923 return NULL;
16924 }
16925
16926
16927 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16928 PyObject *resultobj;
16929 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16930 int result;
16931 PyObject * obj0 = 0 ;
16932 char *kwnames[] = {
16933 (char *) "self", NULL
16934 };
16935
16936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16938 if (SWIG_arg_fail(1)) SWIG_fail;
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16942
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 {
16947 resultobj = SWIG_From_int((int)(result));
16948 }
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj;
16957 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16958 int result;
16959 PyObject * obj0 = 0 ;
16960 char *kwnames[] = {
16961 (char *) "self", NULL
16962 };
16963
16964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16966 if (SWIG_arg_fail(1)) SWIG_fail;
16967 {
16968 PyThreadState* __tstate = wxPyBeginAllowThreads();
16969 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16970
16971 wxPyEndAllowThreads(__tstate);
16972 if (PyErr_Occurred()) SWIG_fail;
16973 }
16974 {
16975 resultobj = SWIG_From_int((int)(result));
16976 }
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16984 PyObject *resultobj;
16985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16986 bool result;
16987 PyObject * obj0 = 0 ;
16988 char *kwnames[] = {
16989 (char *) "self", NULL
16990 };
16991
16992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16994 if (SWIG_arg_fail(1)) SWIG_fail;
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16998
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 {
17003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17004 }
17005 return resultobj;
17006 fail:
17007 return NULL;
17008 }
17009
17010
17011 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17012 PyObject *resultobj;
17013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17014 int arg2 ;
17015 PyObject * obj0 = 0 ;
17016 PyObject * obj1 = 0 ;
17017 char *kwnames[] = {
17018 (char *) "self",(char *) "m_x", NULL
17019 };
17020
17021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17023 if (SWIG_arg_fail(1)) SWIG_fail;
17024 {
17025 arg2 = (int)(SWIG_As_int(obj1));
17026 if (SWIG_arg_fail(2)) SWIG_fail;
17027 }
17028 if (arg1) (arg1)->m_x = arg2;
17029
17030 Py_INCREF(Py_None); resultobj = Py_None;
17031 return resultobj;
17032 fail:
17033 return NULL;
17034 }
17035
17036
17037 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17038 PyObject *resultobj;
17039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17040 int result;
17041 PyObject * obj0 = 0 ;
17042 char *kwnames[] = {
17043 (char *) "self", NULL
17044 };
17045
17046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_x);
17050
17051 {
17052 resultobj = SWIG_From_int((int)(result));
17053 }
17054 return resultobj;
17055 fail:
17056 return NULL;
17057 }
17058
17059
17060 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj;
17062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17063 int arg2 ;
17064 PyObject * obj0 = 0 ;
17065 PyObject * obj1 = 0 ;
17066 char *kwnames[] = {
17067 (char *) "self",(char *) "m_y", NULL
17068 };
17069
17070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17072 if (SWIG_arg_fail(1)) SWIG_fail;
17073 {
17074 arg2 = (int)(SWIG_As_int(obj1));
17075 if (SWIG_arg_fail(2)) SWIG_fail;
17076 }
17077 if (arg1) (arg1)->m_y = arg2;
17078
17079 Py_INCREF(Py_None); resultobj = Py_None;
17080 return resultobj;
17081 fail:
17082 return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj;
17088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17089 int result;
17090 PyObject * obj0 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self", NULL
17093 };
17094
17095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_y);
17099
17100 {
17101 resultobj = SWIG_From_int((int)(result));
17102 }
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj;
17111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17112 bool arg2 ;
17113 PyObject * obj0 = 0 ;
17114 PyObject * obj1 = 0 ;
17115 char *kwnames[] = {
17116 (char *) "self",(char *) "m_leftDown", NULL
17117 };
17118
17119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17121 if (SWIG_arg_fail(1)) SWIG_fail;
17122 {
17123 arg2 = (bool)(SWIG_As_bool(obj1));
17124 if (SWIG_arg_fail(2)) SWIG_fail;
17125 }
17126 if (arg1) (arg1)->m_leftDown = arg2;
17127
17128 Py_INCREF(Py_None); resultobj = Py_None;
17129 return resultobj;
17130 fail:
17131 return NULL;
17132 }
17133
17134
17135 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17136 PyObject *resultobj;
17137 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17138 bool result;
17139 PyObject * obj0 = 0 ;
17140 char *kwnames[] = {
17141 (char *) "self", NULL
17142 };
17143
17144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_leftDown);
17148
17149 {
17150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17151 }
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17159 PyObject *resultobj;
17160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17161 bool arg2 ;
17162 PyObject * obj0 = 0 ;
17163 PyObject * obj1 = 0 ;
17164 char *kwnames[] = {
17165 (char *) "self",(char *) "m_middleDown", NULL
17166 };
17167
17168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17170 if (SWIG_arg_fail(1)) SWIG_fail;
17171 {
17172 arg2 = (bool)(SWIG_As_bool(obj1));
17173 if (SWIG_arg_fail(2)) SWIG_fail;
17174 }
17175 if (arg1) (arg1)->m_middleDown = arg2;
17176
17177 Py_INCREF(Py_None); resultobj = Py_None;
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17185 PyObject *resultobj;
17186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17187 bool result;
17188 PyObject * obj0 = 0 ;
17189 char *kwnames[] = {
17190 (char *) "self", NULL
17191 };
17192
17193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_middleDown);
17197
17198 {
17199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17200 }
17201 return resultobj;
17202 fail:
17203 return NULL;
17204 }
17205
17206
17207 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17208 PyObject *resultobj;
17209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17210 bool arg2 ;
17211 PyObject * obj0 = 0 ;
17212 PyObject * obj1 = 0 ;
17213 char *kwnames[] = {
17214 (char *) "self",(char *) "m_rightDown", NULL
17215 };
17216
17217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17219 if (SWIG_arg_fail(1)) SWIG_fail;
17220 {
17221 arg2 = (bool)(SWIG_As_bool(obj1));
17222 if (SWIG_arg_fail(2)) SWIG_fail;
17223 }
17224 if (arg1) (arg1)->m_rightDown = arg2;
17225
17226 Py_INCREF(Py_None); resultobj = Py_None;
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17234 PyObject *resultobj;
17235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17236 bool result;
17237 PyObject * obj0 = 0 ;
17238 char *kwnames[] = {
17239 (char *) "self", NULL
17240 };
17241
17242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_rightDown);
17246
17247 {
17248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17249 }
17250 return resultobj;
17251 fail:
17252 return NULL;
17253 }
17254
17255
17256 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17257 PyObject *resultobj;
17258 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17259 bool arg2 ;
17260 PyObject * obj0 = 0 ;
17261 PyObject * obj1 = 0 ;
17262 char *kwnames[] = {
17263 (char *) "self",(char *) "m_controlDown", NULL
17264 };
17265
17266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17268 if (SWIG_arg_fail(1)) SWIG_fail;
17269 {
17270 arg2 = (bool)(SWIG_As_bool(obj1));
17271 if (SWIG_arg_fail(2)) SWIG_fail;
17272 }
17273 if (arg1) (arg1)->m_controlDown = arg2;
17274
17275 Py_INCREF(Py_None); resultobj = Py_None;
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17285 bool result;
17286 PyObject * obj0 = 0 ;
17287 char *kwnames[] = {
17288 (char *) "self", NULL
17289 };
17290
17291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_controlDown);
17295
17296 {
17297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17298 }
17299 return resultobj;
17300 fail:
17301 return NULL;
17302 }
17303
17304
17305 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17306 PyObject *resultobj;
17307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17308 bool arg2 ;
17309 PyObject * obj0 = 0 ;
17310 PyObject * obj1 = 0 ;
17311 char *kwnames[] = {
17312 (char *) "self",(char *) "m_shiftDown", NULL
17313 };
17314
17315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17317 if (SWIG_arg_fail(1)) SWIG_fail;
17318 {
17319 arg2 = (bool)(SWIG_As_bool(obj1));
17320 if (SWIG_arg_fail(2)) SWIG_fail;
17321 }
17322 if (arg1) (arg1)->m_shiftDown = arg2;
17323
17324 Py_INCREF(Py_None); resultobj = Py_None;
17325 return resultobj;
17326 fail:
17327 return NULL;
17328 }
17329
17330
17331 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17332 PyObject *resultobj;
17333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17334 bool result;
17335 PyObject * obj0 = 0 ;
17336 char *kwnames[] = {
17337 (char *) "self", NULL
17338 };
17339
17340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_shiftDown);
17344
17345 {
17346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17347 }
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17355 PyObject *resultobj;
17356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17357 bool arg2 ;
17358 PyObject * obj0 = 0 ;
17359 PyObject * obj1 = 0 ;
17360 char *kwnames[] = {
17361 (char *) "self",(char *) "m_altDown", NULL
17362 };
17363
17364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17366 if (SWIG_arg_fail(1)) SWIG_fail;
17367 {
17368 arg2 = (bool)(SWIG_As_bool(obj1));
17369 if (SWIG_arg_fail(2)) SWIG_fail;
17370 }
17371 if (arg1) (arg1)->m_altDown = arg2;
17372
17373 Py_INCREF(Py_None); resultobj = Py_None;
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj;
17382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17383 bool result;
17384 PyObject * obj0 = 0 ;
17385 char *kwnames[] = {
17386 (char *) "self", NULL
17387 };
17388
17389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_altDown);
17393
17394 {
17395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17396 }
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj;
17405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17406 bool arg2 ;
17407 PyObject * obj0 = 0 ;
17408 PyObject * obj1 = 0 ;
17409 char *kwnames[] = {
17410 (char *) "self",(char *) "m_metaDown", NULL
17411 };
17412
17413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17415 if (SWIG_arg_fail(1)) SWIG_fail;
17416 {
17417 arg2 = (bool)(SWIG_As_bool(obj1));
17418 if (SWIG_arg_fail(2)) SWIG_fail;
17419 }
17420 if (arg1) (arg1)->m_metaDown = arg2;
17421
17422 Py_INCREF(Py_None); resultobj = Py_None;
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 bool result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 result = (bool) ((arg1)->m_metaDown);
17442
17443 {
17444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17445 }
17446 return resultobj;
17447 fail:
17448 return NULL;
17449 }
17450
17451
17452 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17453 PyObject *resultobj;
17454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17455 int arg2 ;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 char *kwnames[] = {
17459 (char *) "self",(char *) "m_wheelRotation", NULL
17460 };
17461
17462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17464 if (SWIG_arg_fail(1)) SWIG_fail;
17465 {
17466 arg2 = (int)(SWIG_As_int(obj1));
17467 if (SWIG_arg_fail(2)) SWIG_fail;
17468 }
17469 if (arg1) (arg1)->m_wheelRotation = arg2;
17470
17471 Py_INCREF(Py_None); resultobj = Py_None;
17472 return resultobj;
17473 fail:
17474 return NULL;
17475 }
17476
17477
17478 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17479 PyObject *resultobj;
17480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17481 int result;
17482 PyObject * obj0 = 0 ;
17483 char *kwnames[] = {
17484 (char *) "self", NULL
17485 };
17486
17487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17489 if (SWIG_arg_fail(1)) SWIG_fail;
17490 result = (int) ((arg1)->m_wheelRotation);
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_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj;
17503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17504 int arg2 ;
17505 PyObject * obj0 = 0 ;
17506 PyObject * obj1 = 0 ;
17507 char *kwnames[] = {
17508 (char *) "self",(char *) "m_wheelDelta", NULL
17509 };
17510
17511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17513 if (SWIG_arg_fail(1)) SWIG_fail;
17514 {
17515 arg2 = (int)(SWIG_As_int(obj1));
17516 if (SWIG_arg_fail(2)) SWIG_fail;
17517 }
17518 if (arg1) (arg1)->m_wheelDelta = arg2;
17519
17520 Py_INCREF(Py_None); resultobj = Py_None;
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj;
17529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17530 int result;
17531 PyObject * obj0 = 0 ;
17532 char *kwnames[] = {
17533 (char *) "self", NULL
17534 };
17535
17536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17538 if (SWIG_arg_fail(1)) SWIG_fail;
17539 result = (int) ((arg1)->m_wheelDelta);
17540
17541 {
17542 resultobj = SWIG_From_int((int)(result));
17543 }
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17553 int arg2 ;
17554 PyObject * obj0 = 0 ;
17555 PyObject * obj1 = 0 ;
17556 char *kwnames[] = {
17557 (char *) "self",(char *) "m_linesPerAction", NULL
17558 };
17559
17560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17562 if (SWIG_arg_fail(1)) SWIG_fail;
17563 {
17564 arg2 = (int)(SWIG_As_int(obj1));
17565 if (SWIG_arg_fail(2)) SWIG_fail;
17566 }
17567 if (arg1) (arg1)->m_linesPerAction = arg2;
17568
17569 Py_INCREF(Py_None); resultobj = Py_None;
17570 return resultobj;
17571 fail:
17572 return NULL;
17573 }
17574
17575
17576 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17577 PyObject *resultobj;
17578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17579 int result;
17580 PyObject * obj0 = 0 ;
17581 char *kwnames[] = {
17582 (char *) "self", NULL
17583 };
17584
17585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17587 if (SWIG_arg_fail(1)) SWIG_fail;
17588 result = (int) ((arg1)->m_linesPerAction);
17589
17590 {
17591 resultobj = SWIG_From_int((int)(result));
17592 }
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17600 PyObject *obj;
17601 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17602 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17603 Py_INCREF(obj);
17604 return Py_BuildValue((char *)"");
17605 }
17606 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17607 PyObject *resultobj;
17608 int arg1 = (int) 0 ;
17609 int arg2 = (int) 0 ;
17610 wxSetCursorEvent *result;
17611 PyObject * obj0 = 0 ;
17612 PyObject * obj1 = 0 ;
17613 char *kwnames[] = {
17614 (char *) "x",(char *) "y", NULL
17615 };
17616
17617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17618 if (obj0) {
17619 {
17620 arg1 = (int)(SWIG_As_int(obj0));
17621 if (SWIG_arg_fail(1)) SWIG_fail;
17622 }
17623 }
17624 if (obj1) {
17625 {
17626 arg2 = (int)(SWIG_As_int(obj1));
17627 if (SWIG_arg_fail(2)) SWIG_fail;
17628 }
17629 }
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17633
17634 wxPyEndAllowThreads(__tstate);
17635 if (PyErr_Occurred()) SWIG_fail;
17636 }
17637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17638 return resultobj;
17639 fail:
17640 return NULL;
17641 }
17642
17643
17644 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17645 PyObject *resultobj;
17646 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17647 int result;
17648 PyObject * obj0 = 0 ;
17649 char *kwnames[] = {
17650 (char *) "self", NULL
17651 };
17652
17653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17655 if (SWIG_arg_fail(1)) SWIG_fail;
17656 {
17657 PyThreadState* __tstate = wxPyBeginAllowThreads();
17658 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17659
17660 wxPyEndAllowThreads(__tstate);
17661 if (PyErr_Occurred()) SWIG_fail;
17662 }
17663 {
17664 resultobj = SWIG_From_int((int)(result));
17665 }
17666 return resultobj;
17667 fail:
17668 return NULL;
17669 }
17670
17671
17672 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17673 PyObject *resultobj;
17674 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17675 int result;
17676 PyObject * obj0 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 {
17685 PyThreadState* __tstate = wxPyBeginAllowThreads();
17686 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17687
17688 wxPyEndAllowThreads(__tstate);
17689 if (PyErr_Occurred()) SWIG_fail;
17690 }
17691 {
17692 resultobj = SWIG_From_int((int)(result));
17693 }
17694 return resultobj;
17695 fail:
17696 return NULL;
17697 }
17698
17699
17700 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17701 PyObject *resultobj;
17702 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17703 wxCursor *arg2 = 0 ;
17704 PyObject * obj0 = 0 ;
17705 PyObject * obj1 = 0 ;
17706 char *kwnames[] = {
17707 (char *) "self",(char *) "cursor", NULL
17708 };
17709
17710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17712 if (SWIG_arg_fail(1)) SWIG_fail;
17713 {
17714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17715 if (SWIG_arg_fail(2)) SWIG_fail;
17716 if (arg2 == NULL) {
17717 SWIG_null_ref("wxCursor");
17718 }
17719 if (SWIG_arg_fail(2)) SWIG_fail;
17720 }
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 (arg1)->SetCursor((wxCursor const &)*arg2);
17724
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 Py_INCREF(Py_None); resultobj = Py_None;
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17736 PyObject *resultobj;
17737 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17738 wxCursor *result;
17739 PyObject * obj0 = 0 ;
17740 char *kwnames[] = {
17741 (char *) "self", NULL
17742 };
17743
17744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17746 if (SWIG_arg_fail(1)) SWIG_fail;
17747 {
17748 PyThreadState* __tstate = wxPyBeginAllowThreads();
17749 {
17750 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17751 result = (wxCursor *) &_result_ref;
17752 }
17753
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 {
17758 wxCursor* resultptr = new wxCursor(*result);
17759 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17760 }
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj;
17769 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17770 bool result;
17771 PyObject * obj0 = 0 ;
17772 char *kwnames[] = {
17773 (char *) "self", NULL
17774 };
17775
17776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17778 if (SWIG_arg_fail(1)) SWIG_fail;
17779 {
17780 PyThreadState* __tstate = wxPyBeginAllowThreads();
17781 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17782
17783 wxPyEndAllowThreads(__tstate);
17784 if (PyErr_Occurred()) SWIG_fail;
17785 }
17786 {
17787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17788 }
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17796 PyObject *obj;
17797 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17798 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17799 Py_INCREF(obj);
17800 return Py_BuildValue((char *)"");
17801 }
17802 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17803 PyObject *resultobj;
17804 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17805 wxKeyEvent *result;
17806 PyObject * obj0 = 0 ;
17807 char *kwnames[] = {
17808 (char *) "keyType", NULL
17809 };
17810
17811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17812 if (obj0) {
17813 {
17814 arg1 = (wxEventType)(SWIG_As_int(obj0));
17815 if (SWIG_arg_fail(1)) SWIG_fail;
17816 }
17817 }
17818 {
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17821
17822 wxPyEndAllowThreads(__tstate);
17823 if (PyErr_Occurred()) SWIG_fail;
17824 }
17825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17833 PyObject *resultobj;
17834 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17835 bool result;
17836 PyObject * obj0 = 0 ;
17837 char *kwnames[] = {
17838 (char *) "self", NULL
17839 };
17840
17841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17843 if (SWIG_arg_fail(1)) SWIG_fail;
17844 {
17845 PyThreadState* __tstate = wxPyBeginAllowThreads();
17846 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17847
17848 wxPyEndAllowThreads(__tstate);
17849 if (PyErr_Occurred()) SWIG_fail;
17850 }
17851 {
17852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17853 }
17854 return resultobj;
17855 fail:
17856 return NULL;
17857 }
17858
17859
17860 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17861 PyObject *resultobj;
17862 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17863 bool result;
17864 PyObject * obj0 = 0 ;
17865 char *kwnames[] = {
17866 (char *) "self", NULL
17867 };
17868
17869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17871 if (SWIG_arg_fail(1)) SWIG_fail;
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17875
17876 wxPyEndAllowThreads(__tstate);
17877 if (PyErr_Occurred()) SWIG_fail;
17878 }
17879 {
17880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17881 }
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17889 PyObject *resultobj;
17890 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17891 bool result;
17892 PyObject * obj0 = 0 ;
17893 char *kwnames[] = {
17894 (char *) "self", NULL
17895 };
17896
17897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17899 if (SWIG_arg_fail(1)) SWIG_fail;
17900 {
17901 PyThreadState* __tstate = wxPyBeginAllowThreads();
17902 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17903
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 {
17908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17909 }
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17917 PyObject *resultobj;
17918 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17919 bool result;
17920 PyObject * obj0 = 0 ;
17921 char *kwnames[] = {
17922 (char *) "self", NULL
17923 };
17924
17925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17927 if (SWIG_arg_fail(1)) SWIG_fail;
17928 {
17929 PyThreadState* __tstate = wxPyBeginAllowThreads();
17930 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17931
17932 wxPyEndAllowThreads(__tstate);
17933 if (PyErr_Occurred()) SWIG_fail;
17934 }
17935 {
17936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17937 }
17938 return resultobj;
17939 fail:
17940 return NULL;
17941 }
17942
17943
17944 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17945 PyObject *resultobj;
17946 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17947 bool result;
17948 PyObject * obj0 = 0 ;
17949 char *kwnames[] = {
17950 (char *) "self", NULL
17951 };
17952
17953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17955 if (SWIG_arg_fail(1)) SWIG_fail;
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17959
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 {
17964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17965 }
17966 return resultobj;
17967 fail:
17968 return NULL;
17969 }
17970
17971
17972 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17973 PyObject *resultobj;
17974 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17975 bool result;
17976 PyObject * obj0 = 0 ;
17977 char *kwnames[] = {
17978 (char *) "self", NULL
17979 };
17980
17981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17983 if (SWIG_arg_fail(1)) SWIG_fail;
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17987
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 {
17992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17993 }
17994 return resultobj;
17995 fail:
17996 return NULL;
17997 }
17998
17999
18000 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18001 PyObject *resultobj;
18002 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18003 int result;
18004 PyObject * obj0 = 0 ;
18005 char *kwnames[] = {
18006 (char *) "self", NULL
18007 };
18008
18009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18011 if (SWIG_arg_fail(1)) SWIG_fail;
18012 {
18013 PyThreadState* __tstate = wxPyBeginAllowThreads();
18014 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18015
18016 wxPyEndAllowThreads(__tstate);
18017 if (PyErr_Occurred()) SWIG_fail;
18018 }
18019 {
18020 resultobj = SWIG_From_int((int)(result));
18021 }
18022 return resultobj;
18023 fail:
18024 return NULL;
18025 }
18026
18027
18028 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18029 PyObject *resultobj;
18030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18031 int result;
18032 PyObject * obj0 = 0 ;
18033 char *kwnames[] = {
18034 (char *) "self", NULL
18035 };
18036
18037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18039 if (SWIG_arg_fail(1)) SWIG_fail;
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18043
18044 wxPyEndAllowThreads(__tstate);
18045 if (PyErr_Occurred()) SWIG_fail;
18046 }
18047 {
18048 resultobj = SWIG_From_int((int)(result));
18049 }
18050 return resultobj;
18051 fail:
18052 return NULL;
18053 }
18054
18055
18056 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18057 PyObject *resultobj;
18058 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18059 unsigned int result;
18060 PyObject * obj0 = 0 ;
18061 char *kwnames[] = {
18062 (char *) "self", NULL
18063 };
18064
18065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18067 if (SWIG_arg_fail(1)) SWIG_fail;
18068 {
18069 PyThreadState* __tstate = wxPyBeginAllowThreads();
18070 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18071
18072 wxPyEndAllowThreads(__tstate);
18073 if (PyErr_Occurred()) SWIG_fail;
18074 }
18075 {
18076 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18077 }
18078 return resultobj;
18079 fail:
18080 return NULL;
18081 }
18082
18083
18084 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18085 PyObject *resultobj;
18086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18087 unsigned int result;
18088 PyObject * obj0 = 0 ;
18089 char *kwnames[] = {
18090 (char *) "self", NULL
18091 };
18092
18093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18095 if (SWIG_arg_fail(1)) SWIG_fail;
18096 {
18097 PyThreadState* __tstate = wxPyBeginAllowThreads();
18098 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18099
18100 wxPyEndAllowThreads(__tstate);
18101 if (PyErr_Occurred()) SWIG_fail;
18102 }
18103 {
18104 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18105 }
18106 return resultobj;
18107 fail:
18108 return NULL;
18109 }
18110
18111
18112 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18113 PyObject *resultobj;
18114 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18115 wxPoint result;
18116 PyObject * obj0 = 0 ;
18117 char *kwnames[] = {
18118 (char *) "self", NULL
18119 };
18120
18121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18123 if (SWIG_arg_fail(1)) SWIG_fail;
18124 {
18125 PyThreadState* __tstate = wxPyBeginAllowThreads();
18126 result = (arg1)->GetPosition();
18127
18128 wxPyEndAllowThreads(__tstate);
18129 if (PyErr_Occurred()) SWIG_fail;
18130 }
18131 {
18132 wxPoint * resultptr;
18133 resultptr = new wxPoint((wxPoint &)(result));
18134 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18135 }
18136 return resultobj;
18137 fail:
18138 return NULL;
18139 }
18140
18141
18142 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18143 PyObject *resultobj;
18144 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18145 long *arg2 = (long *) 0 ;
18146 long *arg3 = (long *) 0 ;
18147 long temp2 ;
18148 int res2 = 0 ;
18149 long temp3 ;
18150 int res3 = 0 ;
18151 PyObject * obj0 = 0 ;
18152 char *kwnames[] = {
18153 (char *) "self", NULL
18154 };
18155
18156 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18157 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18160 if (SWIG_arg_fail(1)) SWIG_fail;
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 (arg1)->GetPosition(arg2,arg3);
18164
18165 wxPyEndAllowThreads(__tstate);
18166 if (PyErr_Occurred()) SWIG_fail;
18167 }
18168 Py_INCREF(Py_None); resultobj = Py_None;
18169 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18170 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18171 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18172 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18173 return resultobj;
18174 fail:
18175 return NULL;
18176 }
18177
18178
18179 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18180 PyObject *resultobj;
18181 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18182 int result;
18183 PyObject * obj0 = 0 ;
18184 char *kwnames[] = {
18185 (char *) "self", NULL
18186 };
18187
18188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18190 if (SWIG_arg_fail(1)) SWIG_fail;
18191 {
18192 PyThreadState* __tstate = wxPyBeginAllowThreads();
18193 result = (int)((wxKeyEvent const *)arg1)->GetX();
18194
18195 wxPyEndAllowThreads(__tstate);
18196 if (PyErr_Occurred()) SWIG_fail;
18197 }
18198 {
18199 resultobj = SWIG_From_int((int)(result));
18200 }
18201 return resultobj;
18202 fail:
18203 return NULL;
18204 }
18205
18206
18207 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18208 PyObject *resultobj;
18209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18210 int result;
18211 PyObject * obj0 = 0 ;
18212 char *kwnames[] = {
18213 (char *) "self", NULL
18214 };
18215
18216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18218 if (SWIG_arg_fail(1)) SWIG_fail;
18219 {
18220 PyThreadState* __tstate = wxPyBeginAllowThreads();
18221 result = (int)((wxKeyEvent const *)arg1)->GetY();
18222
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 {
18227 resultobj = SWIG_From_int((int)(result));
18228 }
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18236 PyObject *resultobj;
18237 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18238 int arg2 ;
18239 PyObject * obj0 = 0 ;
18240 PyObject * obj1 = 0 ;
18241 char *kwnames[] = {
18242 (char *) "self",(char *) "m_x", NULL
18243 };
18244
18245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18247 if (SWIG_arg_fail(1)) SWIG_fail;
18248 {
18249 arg2 = (int)(SWIG_As_int(obj1));
18250 if (SWIG_arg_fail(2)) SWIG_fail;
18251 }
18252 if (arg1) (arg1)->m_x = arg2;
18253
18254 Py_INCREF(Py_None); resultobj = Py_None;
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj;
18263 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18264 int result;
18265 PyObject * obj0 = 0 ;
18266 char *kwnames[] = {
18267 (char *) "self", NULL
18268 };
18269
18270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_x);
18274
18275 {
18276 resultobj = SWIG_From_int((int)(result));
18277 }
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj;
18286 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18287 int arg2 ;
18288 PyObject * obj0 = 0 ;
18289 PyObject * obj1 = 0 ;
18290 char *kwnames[] = {
18291 (char *) "self",(char *) "m_y", NULL
18292 };
18293
18294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18296 if (SWIG_arg_fail(1)) SWIG_fail;
18297 {
18298 arg2 = (int)(SWIG_As_int(obj1));
18299 if (SWIG_arg_fail(2)) SWIG_fail;
18300 }
18301 if (arg1) (arg1)->m_y = arg2;
18302
18303 Py_INCREF(Py_None); resultobj = Py_None;
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18311 PyObject *resultobj;
18312 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18313 int result;
18314 PyObject * obj0 = 0 ;
18315 char *kwnames[] = {
18316 (char *) "self", NULL
18317 };
18318
18319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_y);
18323
18324 {
18325 resultobj = SWIG_From_int((int)(result));
18326 }
18327 return resultobj;
18328 fail:
18329 return NULL;
18330 }
18331
18332
18333 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18334 PyObject *resultobj;
18335 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18336 long arg2 ;
18337 PyObject * obj0 = 0 ;
18338 PyObject * obj1 = 0 ;
18339 char *kwnames[] = {
18340 (char *) "self",(char *) "m_keyCode", NULL
18341 };
18342
18343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18345 if (SWIG_arg_fail(1)) SWIG_fail;
18346 {
18347 arg2 = (long)(SWIG_As_long(obj1));
18348 if (SWIG_arg_fail(2)) SWIG_fail;
18349 }
18350 if (arg1) (arg1)->m_keyCode = arg2;
18351
18352 Py_INCREF(Py_None); resultobj = Py_None;
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj;
18361 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18362 long result;
18363 PyObject * obj0 = 0 ;
18364 char *kwnames[] = {
18365 (char *) "self", NULL
18366 };
18367
18368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) 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 result = (long) ((arg1)->m_keyCode);
18372
18373 {
18374 resultobj = SWIG_From_long((long)(result));
18375 }
18376 return resultobj;
18377 fail:
18378 return NULL;
18379 }
18380
18381
18382 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18383 PyObject *resultobj;
18384 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18385 bool arg2 ;
18386 PyObject * obj0 = 0 ;
18387 PyObject * obj1 = 0 ;
18388 char *kwnames[] = {
18389 (char *) "self",(char *) "m_controlDown", NULL
18390 };
18391
18392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18394 if (SWIG_arg_fail(1)) SWIG_fail;
18395 {
18396 arg2 = (bool)(SWIG_As_bool(obj1));
18397 if (SWIG_arg_fail(2)) SWIG_fail;
18398 }
18399 if (arg1) (arg1)->m_controlDown = arg2;
18400
18401 Py_INCREF(Py_None); resultobj = Py_None;
18402 return resultobj;
18403 fail:
18404 return NULL;
18405 }
18406
18407
18408 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18409 PyObject *resultobj;
18410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18411 bool result;
18412 PyObject * obj0 = 0 ;
18413 char *kwnames[] = {
18414 (char *) "self", NULL
18415 };
18416
18417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_controlDown);
18421
18422 {
18423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18424 }
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18432 PyObject *resultobj;
18433 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18434 bool arg2 ;
18435 PyObject * obj0 = 0 ;
18436 PyObject * obj1 = 0 ;
18437 char *kwnames[] = {
18438 (char *) "self",(char *) "m_shiftDown", NULL
18439 };
18440
18441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18443 if (SWIG_arg_fail(1)) SWIG_fail;
18444 {
18445 arg2 = (bool)(SWIG_As_bool(obj1));
18446 if (SWIG_arg_fail(2)) SWIG_fail;
18447 }
18448 if (arg1) (arg1)->m_shiftDown = arg2;
18449
18450 Py_INCREF(Py_None); resultobj = Py_None;
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj;
18459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18460 bool result;
18461 PyObject * obj0 = 0 ;
18462 char *kwnames[] = {
18463 (char *) "self", NULL
18464 };
18465
18466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_shiftDown);
18470
18471 {
18472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18473 }
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj;
18482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18483 bool arg2 ;
18484 PyObject * obj0 = 0 ;
18485 PyObject * obj1 = 0 ;
18486 char *kwnames[] = {
18487 (char *) "self",(char *) "m_altDown", NULL
18488 };
18489
18490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18492 if (SWIG_arg_fail(1)) SWIG_fail;
18493 {
18494 arg2 = (bool)(SWIG_As_bool(obj1));
18495 if (SWIG_arg_fail(2)) SWIG_fail;
18496 }
18497 if (arg1) (arg1)->m_altDown = arg2;
18498
18499 Py_INCREF(Py_None); resultobj = Py_None;
18500 return resultobj;
18501 fail:
18502 return NULL;
18503 }
18504
18505
18506 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18507 PyObject *resultobj;
18508 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18509 bool result;
18510 PyObject * obj0 = 0 ;
18511 char *kwnames[] = {
18512 (char *) "self", NULL
18513 };
18514
18515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) 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 result = (bool) ((arg1)->m_altDown);
18519
18520 {
18521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18522 }
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18530 PyObject *resultobj;
18531 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18532 bool arg2 ;
18533 PyObject * obj0 = 0 ;
18534 PyObject * obj1 = 0 ;
18535 char *kwnames[] = {
18536 (char *) "self",(char *) "m_metaDown", NULL
18537 };
18538
18539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18541 if (SWIG_arg_fail(1)) SWIG_fail;
18542 {
18543 arg2 = (bool)(SWIG_As_bool(obj1));
18544 if (SWIG_arg_fail(2)) SWIG_fail;
18545 }
18546 if (arg1) (arg1)->m_metaDown = arg2;
18547
18548 Py_INCREF(Py_None); resultobj = Py_None;
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj;
18557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18558 bool result;
18559 PyObject * obj0 = 0 ;
18560 char *kwnames[] = {
18561 (char *) "self", NULL
18562 };
18563
18564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18566 if (SWIG_arg_fail(1)) SWIG_fail;
18567 result = (bool) ((arg1)->m_metaDown);
18568
18569 {
18570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18571 }
18572 return resultobj;
18573 fail:
18574 return NULL;
18575 }
18576
18577
18578 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18579 PyObject *resultobj;
18580 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18581 bool arg2 ;
18582 PyObject * obj0 = 0 ;
18583 PyObject * obj1 = 0 ;
18584 char *kwnames[] = {
18585 (char *) "self",(char *) "m_scanCode", NULL
18586 };
18587
18588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18590 if (SWIG_arg_fail(1)) SWIG_fail;
18591 {
18592 arg2 = (bool)(SWIG_As_bool(obj1));
18593 if (SWIG_arg_fail(2)) SWIG_fail;
18594 }
18595 if (arg1) (arg1)->m_scanCode = arg2;
18596
18597 Py_INCREF(Py_None); resultobj = Py_None;
18598 return resultobj;
18599 fail:
18600 return NULL;
18601 }
18602
18603
18604 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18605 PyObject *resultobj;
18606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18607 bool result;
18608 PyObject * obj0 = 0 ;
18609 char *kwnames[] = {
18610 (char *) "self", NULL
18611 };
18612
18613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18615 if (SWIG_arg_fail(1)) SWIG_fail;
18616 result = (bool) ((arg1)->m_scanCode);
18617
18618 {
18619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18620 }
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18628 PyObject *resultobj;
18629 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18630 unsigned int arg2 ;
18631 PyObject * obj0 = 0 ;
18632 PyObject * obj1 = 0 ;
18633 char *kwnames[] = {
18634 (char *) "self",(char *) "m_rawCode", NULL
18635 };
18636
18637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18639 if (SWIG_arg_fail(1)) SWIG_fail;
18640 {
18641 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18642 if (SWIG_arg_fail(2)) SWIG_fail;
18643 }
18644 if (arg1) (arg1)->m_rawCode = arg2;
18645
18646 Py_INCREF(Py_None); resultobj = Py_None;
18647 return resultobj;
18648 fail:
18649 return NULL;
18650 }
18651
18652
18653 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18654 PyObject *resultobj;
18655 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18656 unsigned int result;
18657 PyObject * obj0 = 0 ;
18658 char *kwnames[] = {
18659 (char *) "self", NULL
18660 };
18661
18662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18664 if (SWIG_arg_fail(1)) SWIG_fail;
18665 result = (unsigned int) ((arg1)->m_rawCode);
18666
18667 {
18668 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18669 }
18670 return resultobj;
18671 fail:
18672 return NULL;
18673 }
18674
18675
18676 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18677 PyObject *resultobj;
18678 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18679 unsigned int arg2 ;
18680 PyObject * obj0 = 0 ;
18681 PyObject * obj1 = 0 ;
18682 char *kwnames[] = {
18683 (char *) "self",(char *) "m_rawFlags", NULL
18684 };
18685
18686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18688 if (SWIG_arg_fail(1)) SWIG_fail;
18689 {
18690 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18691 if (SWIG_arg_fail(2)) SWIG_fail;
18692 }
18693 if (arg1) (arg1)->m_rawFlags = arg2;
18694
18695 Py_INCREF(Py_None); resultobj = Py_None;
18696 return resultobj;
18697 fail:
18698 return NULL;
18699 }
18700
18701
18702 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18703 PyObject *resultobj;
18704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18705 unsigned int result;
18706 PyObject * obj0 = 0 ;
18707 char *kwnames[] = {
18708 (char *) "self", NULL
18709 };
18710
18711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18713 if (SWIG_arg_fail(1)) SWIG_fail;
18714 result = (unsigned int) ((arg1)->m_rawFlags);
18715
18716 {
18717 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18718 }
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18726 PyObject *obj;
18727 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18728 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18729 Py_INCREF(obj);
18730 return Py_BuildValue((char *)"");
18731 }
18732 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18733 PyObject *resultobj;
18734 wxSize const &arg1_defvalue = wxDefaultSize ;
18735 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18736 int arg2 = (int) 0 ;
18737 wxSizeEvent *result;
18738 wxSize temp1 ;
18739 PyObject * obj0 = 0 ;
18740 PyObject * obj1 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "sz",(char *) "winid", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18746 if (obj0) {
18747 {
18748 arg1 = &temp1;
18749 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18750 }
18751 }
18752 if (obj1) {
18753 {
18754 arg2 = (int)(SWIG_As_int(obj1));
18755 if (SWIG_arg_fail(2)) SWIG_fail;
18756 }
18757 }
18758 {
18759 PyThreadState* __tstate = wxPyBeginAllowThreads();
18760 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18761
18762 wxPyEndAllowThreads(__tstate);
18763 if (PyErr_Occurred()) SWIG_fail;
18764 }
18765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18766 return resultobj;
18767 fail:
18768 return NULL;
18769 }
18770
18771
18772 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18773 PyObject *resultobj;
18774 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18775 wxSize result;
18776 PyObject * obj0 = 0 ;
18777 char *kwnames[] = {
18778 (char *) "self", NULL
18779 };
18780
18781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18783 if (SWIG_arg_fail(1)) SWIG_fail;
18784 {
18785 PyThreadState* __tstate = wxPyBeginAllowThreads();
18786 result = ((wxSizeEvent const *)arg1)->GetSize();
18787
18788 wxPyEndAllowThreads(__tstate);
18789 if (PyErr_Occurred()) SWIG_fail;
18790 }
18791 {
18792 wxSize * resultptr;
18793 resultptr = new wxSize((wxSize &)(result));
18794 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18795 }
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj;
18804 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18805 wxRect result;
18806 PyObject * obj0 = 0 ;
18807 char *kwnames[] = {
18808 (char *) "self", NULL
18809 };
18810
18811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18813 if (SWIG_arg_fail(1)) SWIG_fail;
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 result = ((wxSizeEvent const *)arg1)->GetRect();
18817
18818 wxPyEndAllowThreads(__tstate);
18819 if (PyErr_Occurred()) SWIG_fail;
18820 }
18821 {
18822 wxRect * resultptr;
18823 resultptr = new wxRect((wxRect &)(result));
18824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18825 }
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18833 PyObject *resultobj;
18834 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18835 wxRect arg2 ;
18836 PyObject * obj0 = 0 ;
18837 PyObject * obj1 = 0 ;
18838 char *kwnames[] = {
18839 (char *) "self",(char *) "rect", NULL
18840 };
18841
18842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18844 if (SWIG_arg_fail(1)) SWIG_fail;
18845 {
18846 wxRect * argp;
18847 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18848 if (SWIG_arg_fail(2)) SWIG_fail;
18849 if (argp == NULL) {
18850 SWIG_null_ref("wxRect");
18851 }
18852 if (SWIG_arg_fail(2)) SWIG_fail;
18853 arg2 = *argp;
18854 }
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 (arg1)->SetRect(arg2);
18858
18859 wxPyEndAllowThreads(__tstate);
18860 if (PyErr_Occurred()) SWIG_fail;
18861 }
18862 Py_INCREF(Py_None); resultobj = Py_None;
18863 return resultobj;
18864 fail:
18865 return NULL;
18866 }
18867
18868
18869 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18870 PyObject *resultobj;
18871 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18872 wxSize arg2 ;
18873 PyObject * obj0 = 0 ;
18874 PyObject * obj1 = 0 ;
18875 char *kwnames[] = {
18876 (char *) "self",(char *) "size", NULL
18877 };
18878
18879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18881 if (SWIG_arg_fail(1)) SWIG_fail;
18882 {
18883 wxSize * argp;
18884 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18885 if (SWIG_arg_fail(2)) SWIG_fail;
18886 if (argp == NULL) {
18887 SWIG_null_ref("wxSize");
18888 }
18889 if (SWIG_arg_fail(2)) SWIG_fail;
18890 arg2 = *argp;
18891 }
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 wxSizeEvent_SetSize(arg1,arg2);
18895
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 Py_INCREF(Py_None); resultobj = Py_None;
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18907 PyObject *resultobj;
18908 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18909 wxSize *arg2 = (wxSize *) 0 ;
18910 PyObject * obj0 = 0 ;
18911 PyObject * obj1 = 0 ;
18912 char *kwnames[] = {
18913 (char *) "self",(char *) "m_size", NULL
18914 };
18915
18916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18918 if (SWIG_arg_fail(1)) SWIG_fail;
18919 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18920 if (SWIG_arg_fail(2)) SWIG_fail;
18921 if (arg1) (arg1)->m_size = *arg2;
18922
18923 Py_INCREF(Py_None); resultobj = Py_None;
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18931 PyObject *resultobj;
18932 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18933 wxSize *result;
18934 PyObject * obj0 = 0 ;
18935 char *kwnames[] = {
18936 (char *) "self", NULL
18937 };
18938
18939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18941 if (SWIG_arg_fail(1)) SWIG_fail;
18942 result = (wxSize *)& ((arg1)->m_size);
18943
18944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18945 return resultobj;
18946 fail:
18947 return NULL;
18948 }
18949
18950
18951 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18952 PyObject *resultobj;
18953 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18954 wxRect *arg2 = (wxRect *) 0 ;
18955 PyObject * obj0 = 0 ;
18956 PyObject * obj1 = 0 ;
18957 char *kwnames[] = {
18958 (char *) "self",(char *) "m_rect", NULL
18959 };
18960
18961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18963 if (SWIG_arg_fail(1)) SWIG_fail;
18964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18965 if (SWIG_arg_fail(2)) SWIG_fail;
18966 if (arg1) (arg1)->m_rect = *arg2;
18967
18968 Py_INCREF(Py_None); resultobj = Py_None;
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj;
18977 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18978 wxRect *result;
18979 PyObject * obj0 = 0 ;
18980 char *kwnames[] = {
18981 (char *) "self", NULL
18982 };
18983
18984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18986 if (SWIG_arg_fail(1)) SWIG_fail;
18987 result = (wxRect *)& ((arg1)->m_rect);
18988
18989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18997 PyObject *obj;
18998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18999 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19000 Py_INCREF(obj);
19001 return Py_BuildValue((char *)"");
19002 }
19003 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj;
19005 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19006 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19007 int arg2 = (int) 0 ;
19008 wxMoveEvent *result;
19009 wxPoint temp1 ;
19010 PyObject * obj0 = 0 ;
19011 PyObject * obj1 = 0 ;
19012 char *kwnames[] = {
19013 (char *) "pos",(char *) "winid", NULL
19014 };
19015
19016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19017 if (obj0) {
19018 {
19019 arg1 = &temp1;
19020 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19021 }
19022 }
19023 if (obj1) {
19024 {
19025 arg2 = (int)(SWIG_As_int(obj1));
19026 if (SWIG_arg_fail(2)) SWIG_fail;
19027 }
19028 }
19029 {
19030 PyThreadState* __tstate = wxPyBeginAllowThreads();
19031 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19032
19033 wxPyEndAllowThreads(__tstate);
19034 if (PyErr_Occurred()) SWIG_fail;
19035 }
19036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19037 return resultobj;
19038 fail:
19039 return NULL;
19040 }
19041
19042
19043 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19044 PyObject *resultobj;
19045 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19046 wxPoint result;
19047 PyObject * obj0 = 0 ;
19048 char *kwnames[] = {
19049 (char *) "self", NULL
19050 };
19051
19052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19054 if (SWIG_arg_fail(1)) SWIG_fail;
19055 {
19056 PyThreadState* __tstate = wxPyBeginAllowThreads();
19057 result = ((wxMoveEvent const *)arg1)->GetPosition();
19058
19059 wxPyEndAllowThreads(__tstate);
19060 if (PyErr_Occurred()) SWIG_fail;
19061 }
19062 {
19063 wxPoint * resultptr;
19064 resultptr = new wxPoint((wxPoint &)(result));
19065 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19066 }
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19074 PyObject *resultobj;
19075 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19076 wxRect result;
19077 PyObject * obj0 = 0 ;
19078 char *kwnames[] = {
19079 (char *) "self", NULL
19080 };
19081
19082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19084 if (SWIG_arg_fail(1)) SWIG_fail;
19085 {
19086 PyThreadState* __tstate = wxPyBeginAllowThreads();
19087 result = ((wxMoveEvent const *)arg1)->GetRect();
19088
19089 wxPyEndAllowThreads(__tstate);
19090 if (PyErr_Occurred()) SWIG_fail;
19091 }
19092 {
19093 wxRect * resultptr;
19094 resultptr = new wxRect((wxRect &)(result));
19095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19096 }
19097 return resultobj;
19098 fail:
19099 return NULL;
19100 }
19101
19102
19103 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19104 PyObject *resultobj;
19105 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19106 wxRect *arg2 = 0 ;
19107 wxRect temp2 ;
19108 PyObject * obj0 = 0 ;
19109 PyObject * obj1 = 0 ;
19110 char *kwnames[] = {
19111 (char *) "self",(char *) "rect", NULL
19112 };
19113
19114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19116 if (SWIG_arg_fail(1)) SWIG_fail;
19117 {
19118 arg2 = &temp2;
19119 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19120 }
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 (arg1)->SetRect((wxRect const &)*arg2);
19124
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 Py_INCREF(Py_None); resultobj = Py_None;
19129 return resultobj;
19130 fail:
19131 return NULL;
19132 }
19133
19134
19135 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19136 PyObject *resultobj;
19137 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19138 wxPoint *arg2 = 0 ;
19139 wxPoint temp2 ;
19140 PyObject * obj0 = 0 ;
19141 PyObject * obj1 = 0 ;
19142 char *kwnames[] = {
19143 (char *) "self",(char *) "pos", NULL
19144 };
19145
19146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19148 if (SWIG_arg_fail(1)) SWIG_fail;
19149 {
19150 arg2 = &temp2;
19151 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19152 }
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 (arg1)->SetPosition((wxPoint const &)*arg2);
19156
19157 wxPyEndAllowThreads(__tstate);
19158 if (PyErr_Occurred()) SWIG_fail;
19159 }
19160 Py_INCREF(Py_None); resultobj = Py_None;
19161 return resultobj;
19162 fail:
19163 return NULL;
19164 }
19165
19166
19167 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19168 PyObject *obj;
19169 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19170 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19171 Py_INCREF(obj);
19172 return Py_BuildValue((char *)"");
19173 }
19174 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19175 PyObject *resultobj;
19176 int arg1 = (int) 0 ;
19177 wxPaintEvent *result;
19178 PyObject * obj0 = 0 ;
19179 char *kwnames[] = {
19180 (char *) "Id", NULL
19181 };
19182
19183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19184 if (obj0) {
19185 {
19186 arg1 = (int)(SWIG_As_int(obj0));
19187 if (SWIG_arg_fail(1)) SWIG_fail;
19188 }
19189 }
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19193
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19205 PyObject *obj;
19206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19207 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19208 Py_INCREF(obj);
19209 return Py_BuildValue((char *)"");
19210 }
19211 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj;
19213 int arg1 = (int) 0 ;
19214 wxNcPaintEvent *result;
19215 PyObject * obj0 = 0 ;
19216 char *kwnames[] = {
19217 (char *) "winid", NULL
19218 };
19219
19220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19221 if (obj0) {
19222 {
19223 arg1 = (int)(SWIG_As_int(obj0));
19224 if (SWIG_arg_fail(1)) SWIG_fail;
19225 }
19226 }
19227 {
19228 PyThreadState* __tstate = wxPyBeginAllowThreads();
19229 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19230
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19242 PyObject *obj;
19243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19244 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19245 Py_INCREF(obj);
19246 return Py_BuildValue((char *)"");
19247 }
19248 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19249 PyObject *resultobj;
19250 int arg1 = (int) 0 ;
19251 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19252 wxEraseEvent *result;
19253 PyObject * obj0 = 0 ;
19254 PyObject * obj1 = 0 ;
19255 char *kwnames[] = {
19256 (char *) "Id",(char *) "dc", NULL
19257 };
19258
19259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19260 if (obj0) {
19261 {
19262 arg1 = (int)(SWIG_As_int(obj0));
19263 if (SWIG_arg_fail(1)) SWIG_fail;
19264 }
19265 }
19266 if (obj1) {
19267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19268 if (SWIG_arg_fail(2)) SWIG_fail;
19269 }
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19273
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj;
19286 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19287 wxDC *result;
19288 PyObject * obj0 = 0 ;
19289 char *kwnames[] = {
19290 (char *) "self", NULL
19291 };
19292
19293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19295 if (SWIG_arg_fail(1)) SWIG_fail;
19296 {
19297 PyThreadState* __tstate = wxPyBeginAllowThreads();
19298 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19299
19300 wxPyEndAllowThreads(__tstate);
19301 if (PyErr_Occurred()) SWIG_fail;
19302 }
19303 {
19304 resultobj = wxPyMake_wxObject(result, 0);
19305 }
19306 return resultobj;
19307 fail:
19308 return NULL;
19309 }
19310
19311
19312 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19313 PyObject *obj;
19314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19315 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19316 Py_INCREF(obj);
19317 return Py_BuildValue((char *)"");
19318 }
19319 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj;
19321 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19322 int arg2 = (int) 0 ;
19323 wxFocusEvent *result;
19324 PyObject * obj0 = 0 ;
19325 PyObject * obj1 = 0 ;
19326 char *kwnames[] = {
19327 (char *) "type",(char *) "winid", NULL
19328 };
19329
19330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19331 if (obj0) {
19332 {
19333 arg1 = (wxEventType)(SWIG_As_int(obj0));
19334 if (SWIG_arg_fail(1)) SWIG_fail;
19335 }
19336 }
19337 if (obj1) {
19338 {
19339 arg2 = (int)(SWIG_As_int(obj1));
19340 if (SWIG_arg_fail(2)) SWIG_fail;
19341 }
19342 }
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19346
19347 wxPyEndAllowThreads(__tstate);
19348 if (PyErr_Occurred()) SWIG_fail;
19349 }
19350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19351 return resultobj;
19352 fail:
19353 return NULL;
19354 }
19355
19356
19357 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19358 PyObject *resultobj;
19359 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19360 wxWindow *result;
19361 PyObject * obj0 = 0 ;
19362 char *kwnames[] = {
19363 (char *) "self", NULL
19364 };
19365
19366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19368 if (SWIG_arg_fail(1)) SWIG_fail;
19369 {
19370 PyThreadState* __tstate = wxPyBeginAllowThreads();
19371 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19372
19373 wxPyEndAllowThreads(__tstate);
19374 if (PyErr_Occurred()) SWIG_fail;
19375 }
19376 {
19377 resultobj = wxPyMake_wxObject(result, 0);
19378 }
19379 return resultobj;
19380 fail:
19381 return NULL;
19382 }
19383
19384
19385 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19386 PyObject *resultobj;
19387 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19388 wxWindow *arg2 = (wxWindow *) 0 ;
19389 PyObject * obj0 = 0 ;
19390 PyObject * obj1 = 0 ;
19391 char *kwnames[] = {
19392 (char *) "self",(char *) "win", NULL
19393 };
19394
19395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19397 if (SWIG_arg_fail(1)) SWIG_fail;
19398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19399 if (SWIG_arg_fail(2)) SWIG_fail;
19400 {
19401 PyThreadState* __tstate = wxPyBeginAllowThreads();
19402 (arg1)->SetWindow(arg2);
19403
19404 wxPyEndAllowThreads(__tstate);
19405 if (PyErr_Occurred()) SWIG_fail;
19406 }
19407 Py_INCREF(Py_None); resultobj = Py_None;
19408 return resultobj;
19409 fail:
19410 return NULL;
19411 }
19412
19413
19414 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19415 PyObject *obj;
19416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19417 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19418 Py_INCREF(obj);
19419 return Py_BuildValue((char *)"");
19420 }
19421 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19422 PyObject *resultobj;
19423 wxWindow *arg1 = (wxWindow *) NULL ;
19424 wxChildFocusEvent *result;
19425 PyObject * obj0 = 0 ;
19426 char *kwnames[] = {
19427 (char *) "win", NULL
19428 };
19429
19430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19431 if (obj0) {
19432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19433 if (SWIG_arg_fail(1)) SWIG_fail;
19434 }
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19438
19439 wxPyEndAllowThreads(__tstate);
19440 if (PyErr_Occurred()) SWIG_fail;
19441 }
19442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19443 return resultobj;
19444 fail:
19445 return NULL;
19446 }
19447
19448
19449 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19450 PyObject *resultobj;
19451 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19452 wxWindow *result;
19453 PyObject * obj0 = 0 ;
19454 char *kwnames[] = {
19455 (char *) "self", NULL
19456 };
19457
19458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19460 if (SWIG_arg_fail(1)) SWIG_fail;
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19464
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 {
19469 resultobj = wxPyMake_wxObject(result, 0);
19470 }
19471 return resultobj;
19472 fail:
19473 return NULL;
19474 }
19475
19476
19477 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19478 PyObject *obj;
19479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19480 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19481 Py_INCREF(obj);
19482 return Py_BuildValue((char *)"");
19483 }
19484 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19485 PyObject *resultobj;
19486 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19487 bool arg2 = (bool) true ;
19488 int arg3 = (int) 0 ;
19489 wxActivateEvent *result;
19490 PyObject * obj0 = 0 ;
19491 PyObject * obj1 = 0 ;
19492 PyObject * obj2 = 0 ;
19493 char *kwnames[] = {
19494 (char *) "type",(char *) "active",(char *) "Id", NULL
19495 };
19496
19497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19498 if (obj0) {
19499 {
19500 arg1 = (wxEventType)(SWIG_As_int(obj0));
19501 if (SWIG_arg_fail(1)) SWIG_fail;
19502 }
19503 }
19504 if (obj1) {
19505 {
19506 arg2 = (bool)(SWIG_As_bool(obj1));
19507 if (SWIG_arg_fail(2)) SWIG_fail;
19508 }
19509 }
19510 if (obj2) {
19511 {
19512 arg3 = (int)(SWIG_As_int(obj2));
19513 if (SWIG_arg_fail(3)) SWIG_fail;
19514 }
19515 }
19516 {
19517 PyThreadState* __tstate = wxPyBeginAllowThreads();
19518 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19519
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19531 PyObject *resultobj;
19532 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19533 bool result;
19534 PyObject * obj0 = 0 ;
19535 char *kwnames[] = {
19536 (char *) "self", NULL
19537 };
19538
19539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19541 if (SWIG_arg_fail(1)) SWIG_fail;
19542 {
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19545
19546 wxPyEndAllowThreads(__tstate);
19547 if (PyErr_Occurred()) SWIG_fail;
19548 }
19549 {
19550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19551 }
19552 return resultobj;
19553 fail:
19554 return NULL;
19555 }
19556
19557
19558 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19559 PyObject *obj;
19560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19561 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19562 Py_INCREF(obj);
19563 return Py_BuildValue((char *)"");
19564 }
19565 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19566 PyObject *resultobj;
19567 int arg1 = (int) 0 ;
19568 wxInitDialogEvent *result;
19569 PyObject * obj0 = 0 ;
19570 char *kwnames[] = {
19571 (char *) "Id", NULL
19572 };
19573
19574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19575 if (obj0) {
19576 {
19577 arg1 = (int)(SWIG_As_int(obj0));
19578 if (SWIG_arg_fail(1)) SWIG_fail;
19579 }
19580 }
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19584
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19596 PyObject *obj;
19597 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19598 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19599 Py_INCREF(obj);
19600 return Py_BuildValue((char *)"");
19601 }
19602 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19603 PyObject *resultobj;
19604 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19605 int arg2 = (int) 0 ;
19606 wxMenu *arg3 = (wxMenu *) NULL ;
19607 wxMenuEvent *result;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 PyObject * obj2 = 0 ;
19611 char *kwnames[] = {
19612 (char *) "type",(char *) "winid",(char *) "menu", NULL
19613 };
19614
19615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19616 if (obj0) {
19617 {
19618 arg1 = (wxEventType)(SWIG_As_int(obj0));
19619 if (SWIG_arg_fail(1)) SWIG_fail;
19620 }
19621 }
19622 if (obj1) {
19623 {
19624 arg2 = (int)(SWIG_As_int(obj1));
19625 if (SWIG_arg_fail(2)) SWIG_fail;
19626 }
19627 }
19628 if (obj2) {
19629 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19630 if (SWIG_arg_fail(3)) SWIG_fail;
19631 }
19632 {
19633 PyThreadState* __tstate = wxPyBeginAllowThreads();
19634 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19635
19636 wxPyEndAllowThreads(__tstate);
19637 if (PyErr_Occurred()) SWIG_fail;
19638 }
19639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19640 return resultobj;
19641 fail:
19642 return NULL;
19643 }
19644
19645
19646 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19647 PyObject *resultobj;
19648 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19649 int result;
19650 PyObject * obj0 = 0 ;
19651 char *kwnames[] = {
19652 (char *) "self", NULL
19653 };
19654
19655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19657 if (SWIG_arg_fail(1)) SWIG_fail;
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19661
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 {
19666 resultobj = SWIG_From_int((int)(result));
19667 }
19668 return resultobj;
19669 fail:
19670 return NULL;
19671 }
19672
19673
19674 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19675 PyObject *resultobj;
19676 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19677 bool result;
19678 PyObject * obj0 = 0 ;
19679 char *kwnames[] = {
19680 (char *) "self", NULL
19681 };
19682
19683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19685 if (SWIG_arg_fail(1)) SWIG_fail;
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19689
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 {
19694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19695 }
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19703 PyObject *resultobj;
19704 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19705 wxMenu *result;
19706 PyObject * obj0 = 0 ;
19707 char *kwnames[] = {
19708 (char *) "self", NULL
19709 };
19710
19711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19713 if (SWIG_arg_fail(1)) SWIG_fail;
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19717
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 {
19722 resultobj = wxPyMake_wxObject(result, 0);
19723 }
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19731 PyObject *obj;
19732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19733 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19734 Py_INCREF(obj);
19735 return Py_BuildValue((char *)"");
19736 }
19737 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj;
19739 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19740 int arg2 = (int) 0 ;
19741 wxCloseEvent *result;
19742 PyObject * obj0 = 0 ;
19743 PyObject * obj1 = 0 ;
19744 char *kwnames[] = {
19745 (char *) "type",(char *) "winid", NULL
19746 };
19747
19748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19749 if (obj0) {
19750 {
19751 arg1 = (wxEventType)(SWIG_As_int(obj0));
19752 if (SWIG_arg_fail(1)) SWIG_fail;
19753 }
19754 }
19755 if (obj1) {
19756 {
19757 arg2 = (int)(SWIG_As_int(obj1));
19758 if (SWIG_arg_fail(2)) SWIG_fail;
19759 }
19760 }
19761 {
19762 PyThreadState* __tstate = wxPyBeginAllowThreads();
19763 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19764
19765 wxPyEndAllowThreads(__tstate);
19766 if (PyErr_Occurred()) SWIG_fail;
19767 }
19768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj;
19777 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19778 bool arg2 ;
19779 PyObject * obj0 = 0 ;
19780 PyObject * obj1 = 0 ;
19781 char *kwnames[] = {
19782 (char *) "self",(char *) "logOff", NULL
19783 };
19784
19785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19787 if (SWIG_arg_fail(1)) SWIG_fail;
19788 {
19789 arg2 = (bool)(SWIG_As_bool(obj1));
19790 if (SWIG_arg_fail(2)) SWIG_fail;
19791 }
19792 {
19793 PyThreadState* __tstate = wxPyBeginAllowThreads();
19794 (arg1)->SetLoggingOff(arg2);
19795
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 Py_INCREF(Py_None); resultobj = Py_None;
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj;
19808 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19809 bool result;
19810 PyObject * obj0 = 0 ;
19811 char *kwnames[] = {
19812 (char *) "self", NULL
19813 };
19814
19815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19817 if (SWIG_arg_fail(1)) SWIG_fail;
19818 {
19819 PyThreadState* __tstate = wxPyBeginAllowThreads();
19820 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19821
19822 wxPyEndAllowThreads(__tstate);
19823 if (PyErr_Occurred()) SWIG_fail;
19824 }
19825 {
19826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19827 }
19828 return resultobj;
19829 fail:
19830 return NULL;
19831 }
19832
19833
19834 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19835 PyObject *resultobj;
19836 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19837 bool arg2 = (bool) true ;
19838 PyObject * obj0 = 0 ;
19839 PyObject * obj1 = 0 ;
19840 char *kwnames[] = {
19841 (char *) "self",(char *) "veto", NULL
19842 };
19843
19844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19846 if (SWIG_arg_fail(1)) SWIG_fail;
19847 if (obj1) {
19848 {
19849 arg2 = (bool)(SWIG_As_bool(obj1));
19850 if (SWIG_arg_fail(2)) SWIG_fail;
19851 }
19852 }
19853 {
19854 PyThreadState* __tstate = wxPyBeginAllowThreads();
19855 (arg1)->Veto(arg2);
19856
19857 wxPyEndAllowThreads(__tstate);
19858 if (PyErr_Occurred()) SWIG_fail;
19859 }
19860 Py_INCREF(Py_None); resultobj = Py_None;
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19868 PyObject *resultobj;
19869 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19870 bool arg2 ;
19871 PyObject * obj0 = 0 ;
19872 PyObject * obj1 = 0 ;
19873 char *kwnames[] = {
19874 (char *) "self",(char *) "canVeto", NULL
19875 };
19876
19877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19879 if (SWIG_arg_fail(1)) SWIG_fail;
19880 {
19881 arg2 = (bool)(SWIG_As_bool(obj1));
19882 if (SWIG_arg_fail(2)) SWIG_fail;
19883 }
19884 {
19885 PyThreadState* __tstate = wxPyBeginAllowThreads();
19886 (arg1)->SetCanVeto(arg2);
19887
19888 wxPyEndAllowThreads(__tstate);
19889 if (PyErr_Occurred()) SWIG_fail;
19890 }
19891 Py_INCREF(Py_None); resultobj = Py_None;
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj;
19900 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19901 bool result;
19902 PyObject * obj0 = 0 ;
19903 char *kwnames[] = {
19904 (char *) "self", NULL
19905 };
19906
19907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 {
19911 PyThreadState* __tstate = wxPyBeginAllowThreads();
19912 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19913
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 {
19918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19919 }
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj;
19928 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19929 bool result;
19930 PyObject * obj0 = 0 ;
19931 char *kwnames[] = {
19932 (char *) "self", NULL
19933 };
19934
19935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19937 if (SWIG_arg_fail(1)) SWIG_fail;
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19941
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 {
19946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19947 }
19948 return resultobj;
19949 fail:
19950 return NULL;
19951 }
19952
19953
19954 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19955 PyObject *obj;
19956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19957 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19958 Py_INCREF(obj);
19959 return Py_BuildValue((char *)"");
19960 }
19961 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19962 PyObject *resultobj;
19963 int arg1 = (int) 0 ;
19964 bool arg2 = (bool) false ;
19965 wxShowEvent *result;
19966 PyObject * obj0 = 0 ;
19967 PyObject * obj1 = 0 ;
19968 char *kwnames[] = {
19969 (char *) "winid",(char *) "show", NULL
19970 };
19971
19972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19973 if (obj0) {
19974 {
19975 arg1 = (int)(SWIG_As_int(obj0));
19976 if (SWIG_arg_fail(1)) SWIG_fail;
19977 }
19978 }
19979 if (obj1) {
19980 {
19981 arg2 = (bool)(SWIG_As_bool(obj1));
19982 if (SWIG_arg_fail(2)) SWIG_fail;
19983 }
19984 }
19985 {
19986 PyThreadState* __tstate = wxPyBeginAllowThreads();
19987 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19988
19989 wxPyEndAllowThreads(__tstate);
19990 if (PyErr_Occurred()) SWIG_fail;
19991 }
19992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19993 return resultobj;
19994 fail:
19995 return NULL;
19996 }
19997
19998
19999 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20000 PyObject *resultobj;
20001 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20002 bool arg2 ;
20003 PyObject * obj0 = 0 ;
20004 PyObject * obj1 = 0 ;
20005 char *kwnames[] = {
20006 (char *) "self",(char *) "show", NULL
20007 };
20008
20009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20011 if (SWIG_arg_fail(1)) SWIG_fail;
20012 {
20013 arg2 = (bool)(SWIG_As_bool(obj1));
20014 if (SWIG_arg_fail(2)) SWIG_fail;
20015 }
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 (arg1)->SetShow(arg2);
20019
20020 wxPyEndAllowThreads(__tstate);
20021 if (PyErr_Occurred()) SWIG_fail;
20022 }
20023 Py_INCREF(Py_None); resultobj = Py_None;
20024 return resultobj;
20025 fail:
20026 return NULL;
20027 }
20028
20029
20030 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj;
20032 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20033 bool result;
20034 PyObject * obj0 = 0 ;
20035 char *kwnames[] = {
20036 (char *) "self", NULL
20037 };
20038
20039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20041 if (SWIG_arg_fail(1)) SWIG_fail;
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20045
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 {
20050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20051 }
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20059 PyObject *obj;
20060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20061 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20062 Py_INCREF(obj);
20063 return Py_BuildValue((char *)"");
20064 }
20065 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj;
20067 int arg1 = (int) 0 ;
20068 bool arg2 = (bool) true ;
20069 wxIconizeEvent *result;
20070 PyObject * obj0 = 0 ;
20071 PyObject * obj1 = 0 ;
20072 char *kwnames[] = {
20073 (char *) "id",(char *) "iconized", NULL
20074 };
20075
20076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20077 if (obj0) {
20078 {
20079 arg1 = (int)(SWIG_As_int(obj0));
20080 if (SWIG_arg_fail(1)) SWIG_fail;
20081 }
20082 }
20083 if (obj1) {
20084 {
20085 arg2 = (bool)(SWIG_As_bool(obj1));
20086 if (SWIG_arg_fail(2)) SWIG_fail;
20087 }
20088 }
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20092
20093 wxPyEndAllowThreads(__tstate);
20094 if (PyErr_Occurred()) SWIG_fail;
20095 }
20096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20097 return resultobj;
20098 fail:
20099 return NULL;
20100 }
20101
20102
20103 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20104 PyObject *resultobj;
20105 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20106 bool result;
20107 PyObject * obj0 = 0 ;
20108 char *kwnames[] = {
20109 (char *) "self", NULL
20110 };
20111
20112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20114 if (SWIG_arg_fail(1)) SWIG_fail;
20115 {
20116 PyThreadState* __tstate = wxPyBeginAllowThreads();
20117 result = (bool)(arg1)->Iconized();
20118
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 {
20123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20124 }
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20132 PyObject *obj;
20133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20134 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20135 Py_INCREF(obj);
20136 return Py_BuildValue((char *)"");
20137 }
20138 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20139 PyObject *resultobj;
20140 int arg1 = (int) 0 ;
20141 wxMaximizeEvent *result;
20142 PyObject * obj0 = 0 ;
20143 char *kwnames[] = {
20144 (char *) "id", NULL
20145 };
20146
20147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20148 if (obj0) {
20149 {
20150 arg1 = (int)(SWIG_As_int(obj0));
20151 if (SWIG_arg_fail(1)) SWIG_fail;
20152 }
20153 }
20154 {
20155 PyThreadState* __tstate = wxPyBeginAllowThreads();
20156 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20157
20158 wxPyEndAllowThreads(__tstate);
20159 if (PyErr_Occurred()) SWIG_fail;
20160 }
20161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20162 return resultobj;
20163 fail:
20164 return NULL;
20165 }
20166
20167
20168 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20169 PyObject *obj;
20170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20171 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20172 Py_INCREF(obj);
20173 return Py_BuildValue((char *)"");
20174 }
20175 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20176 PyObject *resultobj;
20177 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20178 wxPoint result;
20179 PyObject * obj0 = 0 ;
20180 char *kwnames[] = {
20181 (char *) "self", NULL
20182 };
20183
20184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20186 if (SWIG_arg_fail(1)) SWIG_fail;
20187 {
20188 PyThreadState* __tstate = wxPyBeginAllowThreads();
20189 result = (arg1)->GetPosition();
20190
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 {
20195 wxPoint * resultptr;
20196 resultptr = new wxPoint((wxPoint &)(result));
20197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20198 }
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20206 PyObject *resultobj;
20207 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20208 int result;
20209 PyObject * obj0 = 0 ;
20210 char *kwnames[] = {
20211 (char *) "self", NULL
20212 };
20213
20214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20216 if (SWIG_arg_fail(1)) SWIG_fail;
20217 {
20218 PyThreadState* __tstate = wxPyBeginAllowThreads();
20219 result = (int)(arg1)->GetNumberOfFiles();
20220
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 {
20225 resultobj = SWIG_From_int((int)(result));
20226 }
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20234 PyObject *resultobj;
20235 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20236 PyObject *result;
20237 PyObject * obj0 = 0 ;
20238 char *kwnames[] = {
20239 (char *) "self", NULL
20240 };
20241
20242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20244 if (SWIG_arg_fail(1)) SWIG_fail;
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20248
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 resultobj = result;
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20260 PyObject *obj;
20261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20262 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20263 Py_INCREF(obj);
20264 return Py_BuildValue((char *)"");
20265 }
20266 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20267 PyObject *resultobj;
20268 int arg1 = (int) 0 ;
20269 wxUpdateUIEvent *result;
20270 PyObject * obj0 = 0 ;
20271 char *kwnames[] = {
20272 (char *) "commandId", NULL
20273 };
20274
20275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20276 if (obj0) {
20277 {
20278 arg1 = (int)(SWIG_As_int(obj0));
20279 if (SWIG_arg_fail(1)) SWIG_fail;
20280 }
20281 }
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20285
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20297 PyObject *resultobj;
20298 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20299 bool result;
20300 PyObject * obj0 = 0 ;
20301 char *kwnames[] = {
20302 (char *) "self", NULL
20303 };
20304
20305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20307 if (SWIG_arg_fail(1)) SWIG_fail;
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20311
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 {
20316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20317 }
20318 return resultobj;
20319 fail:
20320 return NULL;
20321 }
20322
20323
20324 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20325 PyObject *resultobj;
20326 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20327 bool result;
20328 PyObject * obj0 = 0 ;
20329 char *kwnames[] = {
20330 (char *) "self", NULL
20331 };
20332
20333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20335 if (SWIG_arg_fail(1)) SWIG_fail;
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20339
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 {
20344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20345 }
20346 return resultobj;
20347 fail:
20348 return NULL;
20349 }
20350
20351
20352 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20353 PyObject *resultobj;
20354 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20355 wxString result;
20356 PyObject * obj0 = 0 ;
20357 char *kwnames[] = {
20358 (char *) "self", NULL
20359 };
20360
20361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20363 if (SWIG_arg_fail(1)) SWIG_fail;
20364 {
20365 PyThreadState* __tstate = wxPyBeginAllowThreads();
20366 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20367
20368 wxPyEndAllowThreads(__tstate);
20369 if (PyErr_Occurred()) SWIG_fail;
20370 }
20371 {
20372 #if wxUSE_UNICODE
20373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20374 #else
20375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20376 #endif
20377 }
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj;
20386 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20387 bool result;
20388 PyObject * obj0 = 0 ;
20389 char *kwnames[] = {
20390 (char *) "self", NULL
20391 };
20392
20393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20395 if (SWIG_arg_fail(1)) SWIG_fail;
20396 {
20397 PyThreadState* __tstate = wxPyBeginAllowThreads();
20398 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20399
20400 wxPyEndAllowThreads(__tstate);
20401 if (PyErr_Occurred()) SWIG_fail;
20402 }
20403 {
20404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20405 }
20406 return resultobj;
20407 fail:
20408 return NULL;
20409 }
20410
20411
20412 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20413 PyObject *resultobj;
20414 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20415 bool result;
20416 PyObject * obj0 = 0 ;
20417 char *kwnames[] = {
20418 (char *) "self", NULL
20419 };
20420
20421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20423 if (SWIG_arg_fail(1)) SWIG_fail;
20424 {
20425 PyThreadState* __tstate = wxPyBeginAllowThreads();
20426 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20427
20428 wxPyEndAllowThreads(__tstate);
20429 if (PyErr_Occurred()) SWIG_fail;
20430 }
20431 {
20432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20433 }
20434 return resultobj;
20435 fail:
20436 return NULL;
20437 }
20438
20439
20440 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20441 PyObject *resultobj;
20442 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20443 bool result;
20444 PyObject * obj0 = 0 ;
20445 char *kwnames[] = {
20446 (char *) "self", NULL
20447 };
20448
20449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20451 if (SWIG_arg_fail(1)) SWIG_fail;
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20455
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 {
20460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20461 }
20462 return resultobj;
20463 fail:
20464 return NULL;
20465 }
20466
20467
20468 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20469 PyObject *resultobj;
20470 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20471 bool arg2 ;
20472 PyObject * obj0 = 0 ;
20473 PyObject * obj1 = 0 ;
20474 char *kwnames[] = {
20475 (char *) "self",(char *) "check", NULL
20476 };
20477
20478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20480 if (SWIG_arg_fail(1)) SWIG_fail;
20481 {
20482 arg2 = (bool)(SWIG_As_bool(obj1));
20483 if (SWIG_arg_fail(2)) SWIG_fail;
20484 }
20485 {
20486 PyThreadState* __tstate = wxPyBeginAllowThreads();
20487 (arg1)->Check(arg2);
20488
20489 wxPyEndAllowThreads(__tstate);
20490 if (PyErr_Occurred()) SWIG_fail;
20491 }
20492 Py_INCREF(Py_None); resultobj = Py_None;
20493 return resultobj;
20494 fail:
20495 return NULL;
20496 }
20497
20498
20499 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20500 PyObject *resultobj;
20501 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20502 bool arg2 ;
20503 PyObject * obj0 = 0 ;
20504 PyObject * obj1 = 0 ;
20505 char *kwnames[] = {
20506 (char *) "self",(char *) "enable", NULL
20507 };
20508
20509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20511 if (SWIG_arg_fail(1)) SWIG_fail;
20512 {
20513 arg2 = (bool)(SWIG_As_bool(obj1));
20514 if (SWIG_arg_fail(2)) SWIG_fail;
20515 }
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 (arg1)->Enable(arg2);
20519
20520 wxPyEndAllowThreads(__tstate);
20521 if (PyErr_Occurred()) SWIG_fail;
20522 }
20523 Py_INCREF(Py_None); resultobj = Py_None;
20524 return resultobj;
20525 fail:
20526 return NULL;
20527 }
20528
20529
20530 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20531 PyObject *resultobj;
20532 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20533 wxString *arg2 = 0 ;
20534 bool temp2 = false ;
20535 PyObject * obj0 = 0 ;
20536 PyObject * obj1 = 0 ;
20537 char *kwnames[] = {
20538 (char *) "self",(char *) "text", NULL
20539 };
20540
20541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20543 if (SWIG_arg_fail(1)) SWIG_fail;
20544 {
20545 arg2 = wxString_in_helper(obj1);
20546 if (arg2 == NULL) SWIG_fail;
20547 temp2 = true;
20548 }
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 (arg1)->SetText((wxString const &)*arg2);
20552
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 Py_INCREF(Py_None); resultobj = Py_None;
20557 {
20558 if (temp2)
20559 delete arg2;
20560 }
20561 return resultobj;
20562 fail:
20563 {
20564 if (temp2)
20565 delete arg2;
20566 }
20567 return NULL;
20568 }
20569
20570
20571 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20572 PyObject *resultobj;
20573 long arg1 ;
20574 PyObject * obj0 = 0 ;
20575 char *kwnames[] = {
20576 (char *) "updateInterval", NULL
20577 };
20578
20579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20580 {
20581 arg1 = (long)(SWIG_As_long(obj0));
20582 if (SWIG_arg_fail(1)) SWIG_fail;
20583 }
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 wxUpdateUIEvent::SetUpdateInterval(arg1);
20587
20588 wxPyEndAllowThreads(__tstate);
20589 if (PyErr_Occurred()) SWIG_fail;
20590 }
20591 Py_INCREF(Py_None); resultobj = Py_None;
20592 return resultobj;
20593 fail:
20594 return NULL;
20595 }
20596
20597
20598 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20599 PyObject *resultobj;
20600 long result;
20601 char *kwnames[] = {
20602 NULL
20603 };
20604
20605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20606 {
20607 PyThreadState* __tstate = wxPyBeginAllowThreads();
20608 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20609
20610 wxPyEndAllowThreads(__tstate);
20611 if (PyErr_Occurred()) SWIG_fail;
20612 }
20613 {
20614 resultobj = SWIG_From_long((long)(result));
20615 }
20616 return resultobj;
20617 fail:
20618 return NULL;
20619 }
20620
20621
20622 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20623 PyObject *resultobj;
20624 wxWindow *arg1 = (wxWindow *) 0 ;
20625 bool result;
20626 PyObject * obj0 = 0 ;
20627 char *kwnames[] = {
20628 (char *) "win", NULL
20629 };
20630
20631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20633 if (SWIG_arg_fail(1)) SWIG_fail;
20634 {
20635 PyThreadState* __tstate = wxPyBeginAllowThreads();
20636 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20637
20638 wxPyEndAllowThreads(__tstate);
20639 if (PyErr_Occurred()) SWIG_fail;
20640 }
20641 {
20642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20643 }
20644 return resultobj;
20645 fail:
20646 return NULL;
20647 }
20648
20649
20650 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj;
20652 char *kwnames[] = {
20653 NULL
20654 };
20655
20656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20657 {
20658 PyThreadState* __tstate = wxPyBeginAllowThreads();
20659 wxUpdateUIEvent::ResetUpdateTime();
20660
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 Py_INCREF(Py_None); resultobj = Py_None;
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj;
20673 wxUpdateUIMode arg1 ;
20674 PyObject * obj0 = 0 ;
20675 char *kwnames[] = {
20676 (char *) "mode", NULL
20677 };
20678
20679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20680 {
20681 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20682 if (SWIG_arg_fail(1)) SWIG_fail;
20683 }
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20687
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 Py_INCREF(Py_None); resultobj = Py_None;
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20699 PyObject *resultobj;
20700 wxUpdateUIMode result;
20701 char *kwnames[] = {
20702 NULL
20703 };
20704
20705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20706 {
20707 PyThreadState* __tstate = wxPyBeginAllowThreads();
20708 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20709
20710 wxPyEndAllowThreads(__tstate);
20711 if (PyErr_Occurred()) SWIG_fail;
20712 }
20713 resultobj = SWIG_From_int((result));
20714 return resultobj;
20715 fail:
20716 return NULL;
20717 }
20718
20719
20720 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20721 PyObject *obj;
20722 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20723 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20724 Py_INCREF(obj);
20725 return Py_BuildValue((char *)"");
20726 }
20727 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20728 PyObject *resultobj;
20729 wxSysColourChangedEvent *result;
20730 char *kwnames[] = {
20731 NULL
20732 };
20733
20734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20735 {
20736 PyThreadState* __tstate = wxPyBeginAllowThreads();
20737 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20738
20739 wxPyEndAllowThreads(__tstate);
20740 if (PyErr_Occurred()) SWIG_fail;
20741 }
20742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20743 return resultobj;
20744 fail:
20745 return NULL;
20746 }
20747
20748
20749 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20750 PyObject *obj;
20751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20752 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20753 Py_INCREF(obj);
20754 return Py_BuildValue((char *)"");
20755 }
20756 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20757 PyObject *resultobj;
20758 int arg1 = (int) 0 ;
20759 wxWindow *arg2 = (wxWindow *) NULL ;
20760 wxMouseCaptureChangedEvent *result;
20761 PyObject * obj0 = 0 ;
20762 PyObject * obj1 = 0 ;
20763 char *kwnames[] = {
20764 (char *) "winid",(char *) "gainedCapture", NULL
20765 };
20766
20767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20768 if (obj0) {
20769 {
20770 arg1 = (int)(SWIG_As_int(obj0));
20771 if (SWIG_arg_fail(1)) SWIG_fail;
20772 }
20773 }
20774 if (obj1) {
20775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20776 if (SWIG_arg_fail(2)) SWIG_fail;
20777 }
20778 {
20779 PyThreadState* __tstate = wxPyBeginAllowThreads();
20780 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20781
20782 wxPyEndAllowThreads(__tstate);
20783 if (PyErr_Occurred()) SWIG_fail;
20784 }
20785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20786 return resultobj;
20787 fail:
20788 return NULL;
20789 }
20790
20791
20792 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20793 PyObject *resultobj;
20794 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20795 wxWindow *result;
20796 PyObject * obj0 = 0 ;
20797 char *kwnames[] = {
20798 (char *) "self", NULL
20799 };
20800
20801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20803 if (SWIG_arg_fail(1)) SWIG_fail;
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20807
20808 wxPyEndAllowThreads(__tstate);
20809 if (PyErr_Occurred()) SWIG_fail;
20810 }
20811 {
20812 resultobj = wxPyMake_wxObject(result, 0);
20813 }
20814 return resultobj;
20815 fail:
20816 return NULL;
20817 }
20818
20819
20820 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20821 PyObject *obj;
20822 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20823 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20824 Py_INCREF(obj);
20825 return Py_BuildValue((char *)"");
20826 }
20827 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20828 PyObject *resultobj;
20829 wxDisplayChangedEvent *result;
20830 char *kwnames[] = {
20831 NULL
20832 };
20833
20834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20835 {
20836 PyThreadState* __tstate = wxPyBeginAllowThreads();
20837 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20838
20839 wxPyEndAllowThreads(__tstate);
20840 if (PyErr_Occurred()) SWIG_fail;
20841 }
20842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20843 return resultobj;
20844 fail:
20845 return NULL;
20846 }
20847
20848
20849 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20850 PyObject *obj;
20851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20852 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20853 Py_INCREF(obj);
20854 return Py_BuildValue((char *)"");
20855 }
20856 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20857 PyObject *resultobj;
20858 int arg1 = (int) 0 ;
20859 wxPaletteChangedEvent *result;
20860 PyObject * obj0 = 0 ;
20861 char *kwnames[] = {
20862 (char *) "id", NULL
20863 };
20864
20865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20866 if (obj0) {
20867 {
20868 arg1 = (int)(SWIG_As_int(obj0));
20869 if (SWIG_arg_fail(1)) SWIG_fail;
20870 }
20871 }
20872 {
20873 PyThreadState* __tstate = wxPyBeginAllowThreads();
20874 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20875
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20887 PyObject *resultobj;
20888 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20889 wxWindow *arg2 = (wxWindow *) 0 ;
20890 PyObject * obj0 = 0 ;
20891 PyObject * obj1 = 0 ;
20892 char *kwnames[] = {
20893 (char *) "self",(char *) "win", NULL
20894 };
20895
20896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20898 if (SWIG_arg_fail(1)) SWIG_fail;
20899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20900 if (SWIG_arg_fail(2)) SWIG_fail;
20901 {
20902 PyThreadState* __tstate = wxPyBeginAllowThreads();
20903 (arg1)->SetChangedWindow(arg2);
20904
20905 wxPyEndAllowThreads(__tstate);
20906 if (PyErr_Occurred()) SWIG_fail;
20907 }
20908 Py_INCREF(Py_None); resultobj = Py_None;
20909 return resultobj;
20910 fail:
20911 return NULL;
20912 }
20913
20914
20915 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20916 PyObject *resultobj;
20917 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20918 wxWindow *result;
20919 PyObject * obj0 = 0 ;
20920 char *kwnames[] = {
20921 (char *) "self", NULL
20922 };
20923
20924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20926 if (SWIG_arg_fail(1)) SWIG_fail;
20927 {
20928 PyThreadState* __tstate = wxPyBeginAllowThreads();
20929 result = (wxWindow *)(arg1)->GetChangedWindow();
20930
20931 wxPyEndAllowThreads(__tstate);
20932 if (PyErr_Occurred()) SWIG_fail;
20933 }
20934 {
20935 resultobj = wxPyMake_wxObject(result, 0);
20936 }
20937 return resultobj;
20938 fail:
20939 return NULL;
20940 }
20941
20942
20943 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20944 PyObject *obj;
20945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20946 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20947 Py_INCREF(obj);
20948 return Py_BuildValue((char *)"");
20949 }
20950 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20951 PyObject *resultobj;
20952 int arg1 = (int) 0 ;
20953 wxQueryNewPaletteEvent *result;
20954 PyObject * obj0 = 0 ;
20955 char *kwnames[] = {
20956 (char *) "winid", NULL
20957 };
20958
20959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20960 if (obj0) {
20961 {
20962 arg1 = (int)(SWIG_As_int(obj0));
20963 if (SWIG_arg_fail(1)) SWIG_fail;
20964 }
20965 }
20966 {
20967 PyThreadState* __tstate = wxPyBeginAllowThreads();
20968 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20969
20970 wxPyEndAllowThreads(__tstate);
20971 if (PyErr_Occurred()) SWIG_fail;
20972 }
20973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20974 return resultobj;
20975 fail:
20976 return NULL;
20977 }
20978
20979
20980 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20981 PyObject *resultobj;
20982 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20983 bool arg2 ;
20984 PyObject * obj0 = 0 ;
20985 PyObject * obj1 = 0 ;
20986 char *kwnames[] = {
20987 (char *) "self",(char *) "realized", NULL
20988 };
20989
20990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20992 if (SWIG_arg_fail(1)) SWIG_fail;
20993 {
20994 arg2 = (bool)(SWIG_As_bool(obj1));
20995 if (SWIG_arg_fail(2)) SWIG_fail;
20996 }
20997 {
20998 PyThreadState* __tstate = wxPyBeginAllowThreads();
20999 (arg1)->SetPaletteRealized(arg2);
21000
21001 wxPyEndAllowThreads(__tstate);
21002 if (PyErr_Occurred()) SWIG_fail;
21003 }
21004 Py_INCREF(Py_None); resultobj = Py_None;
21005 return resultobj;
21006 fail:
21007 return NULL;
21008 }
21009
21010
21011 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21012 PyObject *resultobj;
21013 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21014 bool result;
21015 PyObject * obj0 = 0 ;
21016 char *kwnames[] = {
21017 (char *) "self", NULL
21018 };
21019
21020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21022 if (SWIG_arg_fail(1)) SWIG_fail;
21023 {
21024 PyThreadState* __tstate = wxPyBeginAllowThreads();
21025 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21026
21027 wxPyEndAllowThreads(__tstate);
21028 if (PyErr_Occurred()) SWIG_fail;
21029 }
21030 {
21031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21032 }
21033 return resultobj;
21034 fail:
21035 return NULL;
21036 }
21037
21038
21039 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21040 PyObject *obj;
21041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21042 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21043 Py_INCREF(obj);
21044 return Py_BuildValue((char *)"");
21045 }
21046 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21047 PyObject *resultobj;
21048 wxNavigationKeyEvent *result;
21049 char *kwnames[] = {
21050 NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21054 {
21055 PyThreadState* __tstate = wxPyBeginAllowThreads();
21056 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21057
21058 wxPyEndAllowThreads(__tstate);
21059 if (PyErr_Occurred()) SWIG_fail;
21060 }
21061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21062 return resultobj;
21063 fail:
21064 return NULL;
21065 }
21066
21067
21068 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21069 PyObject *resultobj;
21070 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21071 bool result;
21072 PyObject * obj0 = 0 ;
21073 char *kwnames[] = {
21074 (char *) "self", NULL
21075 };
21076
21077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21079 if (SWIG_arg_fail(1)) SWIG_fail;
21080 {
21081 PyThreadState* __tstate = wxPyBeginAllowThreads();
21082 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21083
21084 wxPyEndAllowThreads(__tstate);
21085 if (PyErr_Occurred()) SWIG_fail;
21086 }
21087 {
21088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21089 }
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21097 PyObject *resultobj;
21098 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21099 bool arg2 ;
21100 PyObject * obj0 = 0 ;
21101 PyObject * obj1 = 0 ;
21102 char *kwnames[] = {
21103 (char *) "self",(char *) "forward", NULL
21104 };
21105
21106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21108 if (SWIG_arg_fail(1)) SWIG_fail;
21109 {
21110 arg2 = (bool)(SWIG_As_bool(obj1));
21111 if (SWIG_arg_fail(2)) SWIG_fail;
21112 }
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 (arg1)->SetDirection(arg2);
21116
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 Py_INCREF(Py_None); resultobj = Py_None;
21121 return resultobj;
21122 fail:
21123 return NULL;
21124 }
21125
21126
21127 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21128 PyObject *resultobj;
21129 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21130 bool result;
21131 PyObject * obj0 = 0 ;
21132 char *kwnames[] = {
21133 (char *) "self", NULL
21134 };
21135
21136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21138 if (SWIG_arg_fail(1)) SWIG_fail;
21139 {
21140 PyThreadState* __tstate = wxPyBeginAllowThreads();
21141 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21142
21143 wxPyEndAllowThreads(__tstate);
21144 if (PyErr_Occurred()) SWIG_fail;
21145 }
21146 {
21147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21148 }
21149 return resultobj;
21150 fail:
21151 return NULL;
21152 }
21153
21154
21155 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21156 PyObject *resultobj;
21157 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21158 bool arg2 ;
21159 PyObject * obj0 = 0 ;
21160 PyObject * obj1 = 0 ;
21161 char *kwnames[] = {
21162 (char *) "self",(char *) "ischange", NULL
21163 };
21164
21165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21167 if (SWIG_arg_fail(1)) SWIG_fail;
21168 {
21169 arg2 = (bool)(SWIG_As_bool(obj1));
21170 if (SWIG_arg_fail(2)) SWIG_fail;
21171 }
21172 {
21173 PyThreadState* __tstate = wxPyBeginAllowThreads();
21174 (arg1)->SetWindowChange(arg2);
21175
21176 wxPyEndAllowThreads(__tstate);
21177 if (PyErr_Occurred()) SWIG_fail;
21178 }
21179 Py_INCREF(Py_None); resultobj = Py_None;
21180 return resultobj;
21181 fail:
21182 return NULL;
21183 }
21184
21185
21186 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21187 PyObject *resultobj;
21188 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21189 bool result;
21190 PyObject * obj0 = 0 ;
21191 char *kwnames[] = {
21192 (char *) "self", NULL
21193 };
21194
21195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21197 if (SWIG_arg_fail(1)) SWIG_fail;
21198 {
21199 PyThreadState* __tstate = wxPyBeginAllowThreads();
21200 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21201
21202 wxPyEndAllowThreads(__tstate);
21203 if (PyErr_Occurred()) SWIG_fail;
21204 }
21205 {
21206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21207 }
21208 return resultobj;
21209 fail:
21210 return NULL;
21211 }
21212
21213
21214 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21215 PyObject *resultobj;
21216 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21217 bool arg2 ;
21218 PyObject * obj0 = 0 ;
21219 PyObject * obj1 = 0 ;
21220 char *kwnames[] = {
21221 (char *) "self",(char *) "bIs", NULL
21222 };
21223
21224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21226 if (SWIG_arg_fail(1)) SWIG_fail;
21227 {
21228 arg2 = (bool)(SWIG_As_bool(obj1));
21229 if (SWIG_arg_fail(2)) SWIG_fail;
21230 }
21231 {
21232 PyThreadState* __tstate = wxPyBeginAllowThreads();
21233 (arg1)->SetFromTab(arg2);
21234
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 Py_INCREF(Py_None); resultobj = Py_None;
21239 return resultobj;
21240 fail:
21241 return NULL;
21242 }
21243
21244
21245 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21246 PyObject *resultobj;
21247 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21248 long arg2 ;
21249 PyObject * obj0 = 0 ;
21250 PyObject * obj1 = 0 ;
21251 char *kwnames[] = {
21252 (char *) "self",(char *) "flags", NULL
21253 };
21254
21255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21257 if (SWIG_arg_fail(1)) SWIG_fail;
21258 {
21259 arg2 = (long)(SWIG_As_long(obj1));
21260 if (SWIG_arg_fail(2)) SWIG_fail;
21261 }
21262 {
21263 PyThreadState* __tstate = wxPyBeginAllowThreads();
21264 (arg1)->SetFlags(arg2);
21265
21266 wxPyEndAllowThreads(__tstate);
21267 if (PyErr_Occurred()) SWIG_fail;
21268 }
21269 Py_INCREF(Py_None); resultobj = Py_None;
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21277 PyObject *resultobj;
21278 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21279 wxWindow *result;
21280 PyObject * obj0 = 0 ;
21281 char *kwnames[] = {
21282 (char *) "self", NULL
21283 };
21284
21285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21287 if (SWIG_arg_fail(1)) SWIG_fail;
21288 {
21289 PyThreadState* __tstate = wxPyBeginAllowThreads();
21290 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21291
21292 wxPyEndAllowThreads(__tstate);
21293 if (PyErr_Occurred()) SWIG_fail;
21294 }
21295 {
21296 resultobj = wxPyMake_wxObject(result, 0);
21297 }
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21305 PyObject *resultobj;
21306 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21307 wxWindow *arg2 = (wxWindow *) 0 ;
21308 PyObject * obj0 = 0 ;
21309 PyObject * obj1 = 0 ;
21310 char *kwnames[] = {
21311 (char *) "self",(char *) "win", NULL
21312 };
21313
21314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21316 if (SWIG_arg_fail(1)) SWIG_fail;
21317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21318 if (SWIG_arg_fail(2)) SWIG_fail;
21319 {
21320 PyThreadState* __tstate = wxPyBeginAllowThreads();
21321 (arg1)->SetCurrentFocus(arg2);
21322
21323 wxPyEndAllowThreads(__tstate);
21324 if (PyErr_Occurred()) SWIG_fail;
21325 }
21326 Py_INCREF(Py_None); resultobj = Py_None;
21327 return resultobj;
21328 fail:
21329 return NULL;
21330 }
21331
21332
21333 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21334 PyObject *obj;
21335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21336 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21337 Py_INCREF(obj);
21338 return Py_BuildValue((char *)"");
21339 }
21340 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21341 PyObject *resultobj;
21342 wxWindow *arg1 = (wxWindow *) NULL ;
21343 wxWindowCreateEvent *result;
21344 PyObject * obj0 = 0 ;
21345 char *kwnames[] = {
21346 (char *) "win", NULL
21347 };
21348
21349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21350 if (obj0) {
21351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21352 if (SWIG_arg_fail(1)) SWIG_fail;
21353 }
21354 {
21355 PyThreadState* __tstate = wxPyBeginAllowThreads();
21356 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21357
21358 wxPyEndAllowThreads(__tstate);
21359 if (PyErr_Occurred()) SWIG_fail;
21360 }
21361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21362 return resultobj;
21363 fail:
21364 return NULL;
21365 }
21366
21367
21368 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21369 PyObject *resultobj;
21370 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21371 wxWindow *result;
21372 PyObject * obj0 = 0 ;
21373 char *kwnames[] = {
21374 (char *) "self", NULL
21375 };
21376
21377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21379 if (SWIG_arg_fail(1)) SWIG_fail;
21380 {
21381 PyThreadState* __tstate = wxPyBeginAllowThreads();
21382 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21383
21384 wxPyEndAllowThreads(__tstate);
21385 if (PyErr_Occurred()) SWIG_fail;
21386 }
21387 {
21388 resultobj = wxPyMake_wxObject(result, 0);
21389 }
21390 return resultobj;
21391 fail:
21392 return NULL;
21393 }
21394
21395
21396 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21397 PyObject *obj;
21398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21399 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21400 Py_INCREF(obj);
21401 return Py_BuildValue((char *)"");
21402 }
21403 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21404 PyObject *resultobj;
21405 wxWindow *arg1 = (wxWindow *) NULL ;
21406 wxWindowDestroyEvent *result;
21407 PyObject * obj0 = 0 ;
21408 char *kwnames[] = {
21409 (char *) "win", NULL
21410 };
21411
21412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21413 if (obj0) {
21414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(1)) SWIG_fail;
21416 }
21417 {
21418 PyThreadState* __tstate = wxPyBeginAllowThreads();
21419 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21420
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21432 PyObject *resultobj;
21433 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21434 wxWindow *result;
21435 PyObject * obj0 = 0 ;
21436 char *kwnames[] = {
21437 (char *) "self", NULL
21438 };
21439
21440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21442 if (SWIG_arg_fail(1)) SWIG_fail;
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21446
21447 wxPyEndAllowThreads(__tstate);
21448 if (PyErr_Occurred()) SWIG_fail;
21449 }
21450 {
21451 resultobj = wxPyMake_wxObject(result, 0);
21452 }
21453 return resultobj;
21454 fail:
21455 return NULL;
21456 }
21457
21458
21459 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21460 PyObject *obj;
21461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21462 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21463 Py_INCREF(obj);
21464 return Py_BuildValue((char *)"");
21465 }
21466 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21467 PyObject *resultobj;
21468 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21469 int arg2 = (int) 0 ;
21470 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21471 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21472 wxContextMenuEvent *result;
21473 wxPoint temp3 ;
21474 PyObject * obj0 = 0 ;
21475 PyObject * obj1 = 0 ;
21476 PyObject * obj2 = 0 ;
21477 char *kwnames[] = {
21478 (char *) "type",(char *) "winid",(char *) "pt", NULL
21479 };
21480
21481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21482 if (obj0) {
21483 {
21484 arg1 = (wxEventType)(SWIG_As_int(obj0));
21485 if (SWIG_arg_fail(1)) SWIG_fail;
21486 }
21487 }
21488 if (obj1) {
21489 {
21490 arg2 = (int)(SWIG_As_int(obj1));
21491 if (SWIG_arg_fail(2)) SWIG_fail;
21492 }
21493 }
21494 if (obj2) {
21495 {
21496 arg3 = &temp3;
21497 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21498 }
21499 }
21500 {
21501 PyThreadState* __tstate = wxPyBeginAllowThreads();
21502 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21503
21504 wxPyEndAllowThreads(__tstate);
21505 if (PyErr_Occurred()) SWIG_fail;
21506 }
21507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21508 return resultobj;
21509 fail:
21510 return NULL;
21511 }
21512
21513
21514 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21515 PyObject *resultobj;
21516 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21517 wxPoint *result;
21518 PyObject * obj0 = 0 ;
21519 char *kwnames[] = {
21520 (char *) "self", NULL
21521 };
21522
21523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21525 if (SWIG_arg_fail(1)) SWIG_fail;
21526 {
21527 PyThreadState* __tstate = wxPyBeginAllowThreads();
21528 {
21529 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21530 result = (wxPoint *) &_result_ref;
21531 }
21532
21533 wxPyEndAllowThreads(__tstate);
21534 if (PyErr_Occurred()) SWIG_fail;
21535 }
21536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21537 return resultobj;
21538 fail:
21539 return NULL;
21540 }
21541
21542
21543 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21544 PyObject *resultobj;
21545 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21546 wxPoint *arg2 = 0 ;
21547 wxPoint temp2 ;
21548 PyObject * obj0 = 0 ;
21549 PyObject * obj1 = 0 ;
21550 char *kwnames[] = {
21551 (char *) "self",(char *) "pos", NULL
21552 };
21553
21554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21556 if (SWIG_arg_fail(1)) SWIG_fail;
21557 {
21558 arg2 = &temp2;
21559 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21560 }
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 (arg1)->SetPosition((wxPoint const &)*arg2);
21564
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 Py_INCREF(Py_None); resultobj = Py_None;
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21576 PyObject *obj;
21577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21578 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21579 Py_INCREF(obj);
21580 return Py_BuildValue((char *)"");
21581 }
21582 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21583 PyObject *resultobj;
21584 wxIdleEvent *result;
21585 char *kwnames[] = {
21586 NULL
21587 };
21588
21589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21590 {
21591 PyThreadState* __tstate = wxPyBeginAllowThreads();
21592 result = (wxIdleEvent *)new wxIdleEvent();
21593
21594 wxPyEndAllowThreads(__tstate);
21595 if (PyErr_Occurred()) SWIG_fail;
21596 }
21597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21598 return resultobj;
21599 fail:
21600 return NULL;
21601 }
21602
21603
21604 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21605 PyObject *resultobj;
21606 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21607 bool arg2 = (bool) true ;
21608 PyObject * obj0 = 0 ;
21609 PyObject * obj1 = 0 ;
21610 char *kwnames[] = {
21611 (char *) "self",(char *) "needMore", NULL
21612 };
21613
21614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21616 if (SWIG_arg_fail(1)) SWIG_fail;
21617 if (obj1) {
21618 {
21619 arg2 = (bool)(SWIG_As_bool(obj1));
21620 if (SWIG_arg_fail(2)) SWIG_fail;
21621 }
21622 }
21623 {
21624 PyThreadState* __tstate = wxPyBeginAllowThreads();
21625 (arg1)->RequestMore(arg2);
21626
21627 wxPyEndAllowThreads(__tstate);
21628 if (PyErr_Occurred()) SWIG_fail;
21629 }
21630 Py_INCREF(Py_None); resultobj = Py_None;
21631 return resultobj;
21632 fail:
21633 return NULL;
21634 }
21635
21636
21637 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21638 PyObject *resultobj;
21639 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21640 bool result;
21641 PyObject * obj0 = 0 ;
21642 char *kwnames[] = {
21643 (char *) "self", NULL
21644 };
21645
21646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21648 if (SWIG_arg_fail(1)) SWIG_fail;
21649 {
21650 PyThreadState* __tstate = wxPyBeginAllowThreads();
21651 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21652
21653 wxPyEndAllowThreads(__tstate);
21654 if (PyErr_Occurred()) SWIG_fail;
21655 }
21656 {
21657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21658 }
21659 return resultobj;
21660 fail:
21661 return NULL;
21662 }
21663
21664
21665 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21666 PyObject *resultobj;
21667 wxIdleMode arg1 ;
21668 PyObject * obj0 = 0 ;
21669 char *kwnames[] = {
21670 (char *) "mode", NULL
21671 };
21672
21673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21674 {
21675 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21676 if (SWIG_arg_fail(1)) SWIG_fail;
21677 }
21678 {
21679 PyThreadState* __tstate = wxPyBeginAllowThreads();
21680 wxIdleEvent::SetMode((wxIdleMode )arg1);
21681
21682 wxPyEndAllowThreads(__tstate);
21683 if (PyErr_Occurred()) SWIG_fail;
21684 }
21685 Py_INCREF(Py_None); resultobj = Py_None;
21686 return resultobj;
21687 fail:
21688 return NULL;
21689 }
21690
21691
21692 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21693 PyObject *resultobj;
21694 wxIdleMode result;
21695 char *kwnames[] = {
21696 NULL
21697 };
21698
21699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 result = (wxIdleMode)wxIdleEvent::GetMode();
21703
21704 wxPyEndAllowThreads(__tstate);
21705 if (PyErr_Occurred()) SWIG_fail;
21706 }
21707 resultobj = SWIG_From_int((result));
21708 return resultobj;
21709 fail:
21710 return NULL;
21711 }
21712
21713
21714 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21715 PyObject *resultobj;
21716 wxWindow *arg1 = (wxWindow *) 0 ;
21717 bool result;
21718 PyObject * obj0 = 0 ;
21719 char *kwnames[] = {
21720 (char *) "win", NULL
21721 };
21722
21723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21725 if (SWIG_arg_fail(1)) SWIG_fail;
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 result = (bool)wxIdleEvent::CanSend(arg1);
21729
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 {
21734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21735 }
21736 return resultobj;
21737 fail:
21738 return NULL;
21739 }
21740
21741
21742 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21743 PyObject *obj;
21744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21745 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21746 Py_INCREF(obj);
21747 return Py_BuildValue((char *)"");
21748 }
21749 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21750 PyObject *resultobj;
21751 int arg1 = (int) 0 ;
21752 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21753 wxPyEvent *result;
21754 PyObject * obj0 = 0 ;
21755 PyObject * obj1 = 0 ;
21756 char *kwnames[] = {
21757 (char *) "winid",(char *) "commandType", NULL
21758 };
21759
21760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21761 if (obj0) {
21762 {
21763 arg1 = (int)(SWIG_As_int(obj0));
21764 if (SWIG_arg_fail(1)) SWIG_fail;
21765 }
21766 }
21767 if (obj1) {
21768 {
21769 arg2 = (wxEventType)(SWIG_As_int(obj1));
21770 if (SWIG_arg_fail(2)) SWIG_fail;
21771 }
21772 }
21773 {
21774 PyThreadState* __tstate = wxPyBeginAllowThreads();
21775 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21776
21777 wxPyEndAllowThreads(__tstate);
21778 if (PyErr_Occurred()) SWIG_fail;
21779 }
21780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21781 return resultobj;
21782 fail:
21783 return NULL;
21784 }
21785
21786
21787 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21788 PyObject *resultobj;
21789 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21790 PyObject * obj0 = 0 ;
21791 char *kwnames[] = {
21792 (char *) "self", NULL
21793 };
21794
21795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21797 if (SWIG_arg_fail(1)) SWIG_fail;
21798 {
21799 PyThreadState* __tstate = wxPyBeginAllowThreads();
21800 delete arg1;
21801
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 Py_INCREF(Py_None); resultobj = Py_None;
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21813 PyObject *resultobj;
21814 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21815 PyObject *arg2 = (PyObject *) 0 ;
21816 PyObject * obj0 = 0 ;
21817 PyObject * obj1 = 0 ;
21818 char *kwnames[] = {
21819 (char *) "self",(char *) "self", NULL
21820 };
21821
21822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21824 if (SWIG_arg_fail(1)) SWIG_fail;
21825 arg2 = obj1;
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 (arg1)->SetSelf(arg2);
21829
21830 wxPyEndAllowThreads(__tstate);
21831 if (PyErr_Occurred()) SWIG_fail;
21832 }
21833 Py_INCREF(Py_None); resultobj = Py_None;
21834 return resultobj;
21835 fail:
21836 return NULL;
21837 }
21838
21839
21840 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21841 PyObject *resultobj;
21842 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21843 PyObject *result;
21844 PyObject * obj0 = 0 ;
21845 char *kwnames[] = {
21846 (char *) "self", NULL
21847 };
21848
21849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21851 if (SWIG_arg_fail(1)) SWIG_fail;
21852 {
21853 PyThreadState* __tstate = wxPyBeginAllowThreads();
21854 result = (PyObject *)(arg1)->GetSelf();
21855
21856 wxPyEndAllowThreads(__tstate);
21857 if (PyErr_Occurred()) SWIG_fail;
21858 }
21859 resultobj = result;
21860 return resultobj;
21861 fail:
21862 return NULL;
21863 }
21864
21865
21866 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21867 PyObject *obj;
21868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21869 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21870 Py_INCREF(obj);
21871 return Py_BuildValue((char *)"");
21872 }
21873 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21874 PyObject *resultobj;
21875 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21876 int arg2 = (int) 0 ;
21877 wxPyCommandEvent *result;
21878 PyObject * obj0 = 0 ;
21879 PyObject * obj1 = 0 ;
21880 char *kwnames[] = {
21881 (char *) "commandType",(char *) "id", NULL
21882 };
21883
21884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21885 if (obj0) {
21886 {
21887 arg1 = (wxEventType)(SWIG_As_int(obj0));
21888 if (SWIG_arg_fail(1)) SWIG_fail;
21889 }
21890 }
21891 if (obj1) {
21892 {
21893 arg2 = (int)(SWIG_As_int(obj1));
21894 if (SWIG_arg_fail(2)) SWIG_fail;
21895 }
21896 }
21897 {
21898 PyThreadState* __tstate = wxPyBeginAllowThreads();
21899 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21900
21901 wxPyEndAllowThreads(__tstate);
21902 if (PyErr_Occurred()) SWIG_fail;
21903 }
21904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21905 return resultobj;
21906 fail:
21907 return NULL;
21908 }
21909
21910
21911 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21912 PyObject *resultobj;
21913 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21914 PyObject * obj0 = 0 ;
21915 char *kwnames[] = {
21916 (char *) "self", NULL
21917 };
21918
21919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21921 if (SWIG_arg_fail(1)) SWIG_fail;
21922 {
21923 PyThreadState* __tstate = wxPyBeginAllowThreads();
21924 delete arg1;
21925
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 Py_INCREF(Py_None); resultobj = Py_None;
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21937 PyObject *resultobj;
21938 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21939 PyObject *arg2 = (PyObject *) 0 ;
21940 PyObject * obj0 = 0 ;
21941 PyObject * obj1 = 0 ;
21942 char *kwnames[] = {
21943 (char *) "self",(char *) "self", NULL
21944 };
21945
21946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21948 if (SWIG_arg_fail(1)) SWIG_fail;
21949 arg2 = obj1;
21950 {
21951 PyThreadState* __tstate = wxPyBeginAllowThreads();
21952 (arg1)->SetSelf(arg2);
21953
21954 wxPyEndAllowThreads(__tstate);
21955 if (PyErr_Occurred()) SWIG_fail;
21956 }
21957 Py_INCREF(Py_None); resultobj = Py_None;
21958 return resultobj;
21959 fail:
21960 return NULL;
21961 }
21962
21963
21964 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21965 PyObject *resultobj;
21966 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21967 PyObject *result;
21968 PyObject * obj0 = 0 ;
21969 char *kwnames[] = {
21970 (char *) "self", NULL
21971 };
21972
21973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21975 if (SWIG_arg_fail(1)) SWIG_fail;
21976 {
21977 PyThreadState* __tstate = wxPyBeginAllowThreads();
21978 result = (PyObject *)(arg1)->GetSelf();
21979
21980 wxPyEndAllowThreads(__tstate);
21981 if (PyErr_Occurred()) SWIG_fail;
21982 }
21983 resultobj = result;
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21991 PyObject *obj;
21992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21993 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21994 Py_INCREF(obj);
21995 return Py_BuildValue((char *)"");
21996 }
21997 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21998 PyObject *resultobj;
21999 wxWindow *arg1 = (wxWindow *) 0 ;
22000 wxDateTime *arg2 = 0 ;
22001 wxEventType arg3 ;
22002 wxDateEvent *result;
22003 PyObject * obj0 = 0 ;
22004 PyObject * obj1 = 0 ;
22005 PyObject * obj2 = 0 ;
22006 char *kwnames[] = {
22007 (char *) "win",(char *) "dt",(char *) "type", NULL
22008 };
22009
22010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22012 if (SWIG_arg_fail(1)) SWIG_fail;
22013 {
22014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22015 if (SWIG_arg_fail(2)) SWIG_fail;
22016 if (arg2 == NULL) {
22017 SWIG_null_ref("wxDateTime");
22018 }
22019 if (SWIG_arg_fail(2)) SWIG_fail;
22020 }
22021 {
22022 arg3 = (wxEventType)(SWIG_As_int(obj2));
22023 if (SWIG_arg_fail(3)) SWIG_fail;
22024 }
22025 {
22026 PyThreadState* __tstate = wxPyBeginAllowThreads();
22027 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22028
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22040 PyObject *resultobj;
22041 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22042 wxDateTime *result;
22043 PyObject * obj0 = 0 ;
22044 char *kwnames[] = {
22045 (char *) "self", NULL
22046 };
22047
22048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22050 if (SWIG_arg_fail(1)) SWIG_fail;
22051 {
22052 PyThreadState* __tstate = wxPyBeginAllowThreads();
22053 {
22054 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22055 result = (wxDateTime *) &_result_ref;
22056 }
22057
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22062 return resultobj;
22063 fail:
22064 return NULL;
22065 }
22066
22067
22068 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22069 PyObject *resultobj;
22070 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22071 wxDateTime *arg2 = 0 ;
22072 PyObject * obj0 = 0 ;
22073 PyObject * obj1 = 0 ;
22074 char *kwnames[] = {
22075 (char *) "self",(char *) "date", NULL
22076 };
22077
22078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22080 if (SWIG_arg_fail(1)) SWIG_fail;
22081 {
22082 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22083 if (SWIG_arg_fail(2)) SWIG_fail;
22084 if (arg2 == NULL) {
22085 SWIG_null_ref("wxDateTime");
22086 }
22087 if (SWIG_arg_fail(2)) SWIG_fail;
22088 }
22089 {
22090 PyThreadState* __tstate = wxPyBeginAllowThreads();
22091 (arg1)->SetDate((wxDateTime const &)*arg2);
22092
22093 wxPyEndAllowThreads(__tstate);
22094 if (PyErr_Occurred()) SWIG_fail;
22095 }
22096 Py_INCREF(Py_None); resultobj = Py_None;
22097 return resultobj;
22098 fail:
22099 return NULL;
22100 }
22101
22102
22103 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22104 PyObject *obj;
22105 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22106 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22107 Py_INCREF(obj);
22108 return Py_BuildValue((char *)"");
22109 }
22110 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22111 PyObject *resultobj;
22112 wxPyApp *result;
22113 char *kwnames[] = {
22114 NULL
22115 };
22116
22117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22118 {
22119 PyThreadState* __tstate = wxPyBeginAllowThreads();
22120 result = (wxPyApp *)new_wxPyApp();
22121
22122 wxPyEndAllowThreads(__tstate);
22123 if (PyErr_Occurred()) SWIG_fail;
22124 }
22125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22126 return resultobj;
22127 fail:
22128 return NULL;
22129 }
22130
22131
22132 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22133 PyObject *resultobj;
22134 wxPyApp *arg1 = (wxPyApp *) 0 ;
22135 PyObject * obj0 = 0 ;
22136 char *kwnames[] = {
22137 (char *) "self", NULL
22138 };
22139
22140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22142 if (SWIG_arg_fail(1)) SWIG_fail;
22143 {
22144 PyThreadState* __tstate = wxPyBeginAllowThreads();
22145 delete arg1;
22146
22147 wxPyEndAllowThreads(__tstate);
22148 if (PyErr_Occurred()) SWIG_fail;
22149 }
22150 Py_INCREF(Py_None); resultobj = Py_None;
22151 return resultobj;
22152 fail:
22153 return NULL;
22154 }
22155
22156
22157 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22158 PyObject *resultobj;
22159 wxPyApp *arg1 = (wxPyApp *) 0 ;
22160 PyObject *arg2 = (PyObject *) 0 ;
22161 PyObject *arg3 = (PyObject *) 0 ;
22162 PyObject * obj0 = 0 ;
22163 PyObject * obj1 = 0 ;
22164 PyObject * obj2 = 0 ;
22165 char *kwnames[] = {
22166 (char *) "self",(char *) "self",(char *) "_class", NULL
22167 };
22168
22169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22171 if (SWIG_arg_fail(1)) SWIG_fail;
22172 arg2 = obj1;
22173 arg3 = obj2;
22174 {
22175 PyThreadState* __tstate = wxPyBeginAllowThreads();
22176 (arg1)->_setCallbackInfo(arg2,arg3);
22177
22178 wxPyEndAllowThreads(__tstate);
22179 if (PyErr_Occurred()) SWIG_fail;
22180 }
22181 Py_INCREF(Py_None); resultobj = Py_None;
22182 return resultobj;
22183 fail:
22184 return NULL;
22185 }
22186
22187
22188 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22189 PyObject *resultobj;
22190 wxPyApp *arg1 = (wxPyApp *) 0 ;
22191 wxString result;
22192 PyObject * obj0 = 0 ;
22193 char *kwnames[] = {
22194 (char *) "self", NULL
22195 };
22196
22197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22199 if (SWIG_arg_fail(1)) SWIG_fail;
22200 {
22201 PyThreadState* __tstate = wxPyBeginAllowThreads();
22202 result = ((wxPyApp const *)arg1)->GetAppName();
22203
22204 wxPyEndAllowThreads(__tstate);
22205 if (PyErr_Occurred()) SWIG_fail;
22206 }
22207 {
22208 #if wxUSE_UNICODE
22209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22210 #else
22211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22212 #endif
22213 }
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22221 PyObject *resultobj;
22222 wxPyApp *arg1 = (wxPyApp *) 0 ;
22223 wxString *arg2 = 0 ;
22224 bool temp2 = false ;
22225 PyObject * obj0 = 0 ;
22226 PyObject * obj1 = 0 ;
22227 char *kwnames[] = {
22228 (char *) "self",(char *) "name", NULL
22229 };
22230
22231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22233 if (SWIG_arg_fail(1)) SWIG_fail;
22234 {
22235 arg2 = wxString_in_helper(obj1);
22236 if (arg2 == NULL) SWIG_fail;
22237 temp2 = true;
22238 }
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 (arg1)->SetAppName((wxString const &)*arg2);
22242
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 Py_INCREF(Py_None); resultobj = Py_None;
22247 {
22248 if (temp2)
22249 delete arg2;
22250 }
22251 return resultobj;
22252 fail:
22253 {
22254 if (temp2)
22255 delete arg2;
22256 }
22257 return NULL;
22258 }
22259
22260
22261 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22262 PyObject *resultobj;
22263 wxPyApp *arg1 = (wxPyApp *) 0 ;
22264 wxString result;
22265 PyObject * obj0 = 0 ;
22266 char *kwnames[] = {
22267 (char *) "self", NULL
22268 };
22269
22270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22272 if (SWIG_arg_fail(1)) SWIG_fail;
22273 {
22274 PyThreadState* __tstate = wxPyBeginAllowThreads();
22275 result = ((wxPyApp const *)arg1)->GetClassName();
22276
22277 wxPyEndAllowThreads(__tstate);
22278 if (PyErr_Occurred()) SWIG_fail;
22279 }
22280 {
22281 #if wxUSE_UNICODE
22282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22283 #else
22284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22285 #endif
22286 }
22287 return resultobj;
22288 fail:
22289 return NULL;
22290 }
22291
22292
22293 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22294 PyObject *resultobj;
22295 wxPyApp *arg1 = (wxPyApp *) 0 ;
22296 wxString *arg2 = 0 ;
22297 bool temp2 = false ;
22298 PyObject * obj0 = 0 ;
22299 PyObject * obj1 = 0 ;
22300 char *kwnames[] = {
22301 (char *) "self",(char *) "name", NULL
22302 };
22303
22304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22306 if (SWIG_arg_fail(1)) SWIG_fail;
22307 {
22308 arg2 = wxString_in_helper(obj1);
22309 if (arg2 == NULL) SWIG_fail;
22310 temp2 = true;
22311 }
22312 {
22313 PyThreadState* __tstate = wxPyBeginAllowThreads();
22314 (arg1)->SetClassName((wxString const &)*arg2);
22315
22316 wxPyEndAllowThreads(__tstate);
22317 if (PyErr_Occurred()) SWIG_fail;
22318 }
22319 Py_INCREF(Py_None); resultobj = Py_None;
22320 {
22321 if (temp2)
22322 delete arg2;
22323 }
22324 return resultobj;
22325 fail:
22326 {
22327 if (temp2)
22328 delete arg2;
22329 }
22330 return NULL;
22331 }
22332
22333
22334 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22335 PyObject *resultobj;
22336 wxPyApp *arg1 = (wxPyApp *) 0 ;
22337 wxString *result;
22338 PyObject * obj0 = 0 ;
22339 char *kwnames[] = {
22340 (char *) "self", NULL
22341 };
22342
22343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22345 if (SWIG_arg_fail(1)) SWIG_fail;
22346 {
22347 PyThreadState* __tstate = wxPyBeginAllowThreads();
22348 {
22349 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22350 result = (wxString *) &_result_ref;
22351 }
22352
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 {
22357 #if wxUSE_UNICODE
22358 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22359 #else
22360 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22361 #endif
22362 }
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22370 PyObject *resultobj;
22371 wxPyApp *arg1 = (wxPyApp *) 0 ;
22372 wxString *arg2 = 0 ;
22373 bool temp2 = false ;
22374 PyObject * obj0 = 0 ;
22375 PyObject * obj1 = 0 ;
22376 char *kwnames[] = {
22377 (char *) "self",(char *) "name", NULL
22378 };
22379
22380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22382 if (SWIG_arg_fail(1)) SWIG_fail;
22383 {
22384 arg2 = wxString_in_helper(obj1);
22385 if (arg2 == NULL) SWIG_fail;
22386 temp2 = true;
22387 }
22388 {
22389 PyThreadState* __tstate = wxPyBeginAllowThreads();
22390 (arg1)->SetVendorName((wxString const &)*arg2);
22391
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 Py_INCREF(Py_None); resultobj = Py_None;
22396 {
22397 if (temp2)
22398 delete arg2;
22399 }
22400 return resultobj;
22401 fail:
22402 {
22403 if (temp2)
22404 delete arg2;
22405 }
22406 return NULL;
22407 }
22408
22409
22410 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22411 PyObject *resultobj;
22412 wxPyApp *arg1 = (wxPyApp *) 0 ;
22413 wxAppTraits *result;
22414 PyObject * obj0 = 0 ;
22415 char *kwnames[] = {
22416 (char *) "self", NULL
22417 };
22418
22419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22421 if (SWIG_arg_fail(1)) SWIG_fail;
22422 {
22423 PyThreadState* __tstate = wxPyBeginAllowThreads();
22424 result = (wxAppTraits *)(arg1)->GetTraits();
22425
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22437 PyObject *resultobj;
22438 wxPyApp *arg1 = (wxPyApp *) 0 ;
22439 PyObject * obj0 = 0 ;
22440 char *kwnames[] = {
22441 (char *) "self", NULL
22442 };
22443
22444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22446 if (SWIG_arg_fail(1)) SWIG_fail;
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 (arg1)->ProcessPendingEvents();
22450
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 Py_INCREF(Py_None); resultobj = Py_None;
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj;
22463 wxPyApp *arg1 = (wxPyApp *) 0 ;
22464 bool arg2 = (bool) false ;
22465 bool result;
22466 PyObject * obj0 = 0 ;
22467 PyObject * obj1 = 0 ;
22468 char *kwnames[] = {
22469 (char *) "self",(char *) "onlyIfNeeded", NULL
22470 };
22471
22472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22474 if (SWIG_arg_fail(1)) SWIG_fail;
22475 if (obj1) {
22476 {
22477 arg2 = (bool)(SWIG_As_bool(obj1));
22478 if (SWIG_arg_fail(2)) SWIG_fail;
22479 }
22480 }
22481 {
22482 PyThreadState* __tstate = wxPyBeginAllowThreads();
22483 result = (bool)(arg1)->Yield(arg2);
22484
22485 wxPyEndAllowThreads(__tstate);
22486 if (PyErr_Occurred()) SWIG_fail;
22487 }
22488 {
22489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22490 }
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22498 PyObject *resultobj;
22499 wxPyApp *arg1 = (wxPyApp *) 0 ;
22500 PyObject * obj0 = 0 ;
22501 char *kwnames[] = {
22502 (char *) "self", NULL
22503 };
22504
22505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22507 if (SWIG_arg_fail(1)) SWIG_fail;
22508 {
22509 PyThreadState* __tstate = wxPyBeginAllowThreads();
22510 (arg1)->WakeUpIdle();
22511
22512 wxPyEndAllowThreads(__tstate);
22513 if (PyErr_Occurred()) SWIG_fail;
22514 }
22515 Py_INCREF(Py_None); resultobj = Py_None;
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22523 PyObject *resultobj;
22524 bool result;
22525 char *kwnames[] = {
22526 NULL
22527 };
22528
22529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22530 {
22531 PyThreadState* __tstate = wxPyBeginAllowThreads();
22532 result = (bool)wxPyApp::IsMainLoopRunning();
22533
22534 wxPyEndAllowThreads(__tstate);
22535 if (PyErr_Occurred()) SWIG_fail;
22536 }
22537 {
22538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22539 }
22540 return resultobj;
22541 fail:
22542 return NULL;
22543 }
22544
22545
22546 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22547 PyObject *resultobj;
22548 wxPyApp *arg1 = (wxPyApp *) 0 ;
22549 int result;
22550 PyObject * obj0 = 0 ;
22551 char *kwnames[] = {
22552 (char *) "self", NULL
22553 };
22554
22555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22557 if (SWIG_arg_fail(1)) SWIG_fail;
22558 {
22559 PyThreadState* __tstate = wxPyBeginAllowThreads();
22560 result = (int)(arg1)->MainLoop();
22561
22562 wxPyEndAllowThreads(__tstate);
22563 if (PyErr_Occurred()) SWIG_fail;
22564 }
22565 {
22566 resultobj = SWIG_From_int((int)(result));
22567 }
22568 return resultobj;
22569 fail:
22570 return NULL;
22571 }
22572
22573
22574 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22575 PyObject *resultobj;
22576 wxPyApp *arg1 = (wxPyApp *) 0 ;
22577 PyObject * obj0 = 0 ;
22578 char *kwnames[] = {
22579 (char *) "self", NULL
22580 };
22581
22582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22584 if (SWIG_arg_fail(1)) SWIG_fail;
22585 {
22586 PyThreadState* __tstate = wxPyBeginAllowThreads();
22587 (arg1)->Exit();
22588
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 Py_INCREF(Py_None); resultobj = Py_None;
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22600 PyObject *resultobj;
22601 wxPyApp *arg1 = (wxPyApp *) 0 ;
22602 PyObject * obj0 = 0 ;
22603 char *kwnames[] = {
22604 (char *) "self", NULL
22605 };
22606
22607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22609 if (SWIG_arg_fail(1)) SWIG_fail;
22610 {
22611 PyThreadState* __tstate = wxPyBeginAllowThreads();
22612 (arg1)->ExitMainLoop();
22613
22614 wxPyEndAllowThreads(__tstate);
22615 if (PyErr_Occurred()) SWIG_fail;
22616 }
22617 Py_INCREF(Py_None); resultobj = Py_None;
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22625 PyObject *resultobj;
22626 wxPyApp *arg1 = (wxPyApp *) 0 ;
22627 bool result;
22628 PyObject * obj0 = 0 ;
22629 char *kwnames[] = {
22630 (char *) "self", NULL
22631 };
22632
22633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22635 if (SWIG_arg_fail(1)) SWIG_fail;
22636 {
22637 PyThreadState* __tstate = wxPyBeginAllowThreads();
22638 result = (bool)(arg1)->Pending();
22639
22640 wxPyEndAllowThreads(__tstate);
22641 if (PyErr_Occurred()) SWIG_fail;
22642 }
22643 {
22644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22645 }
22646 return resultobj;
22647 fail:
22648 return NULL;
22649 }
22650
22651
22652 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22653 PyObject *resultobj;
22654 wxPyApp *arg1 = (wxPyApp *) 0 ;
22655 bool result;
22656 PyObject * obj0 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 result = (bool)(arg1)->Dispatch();
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 {
22672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22673 }
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22681 PyObject *resultobj;
22682 wxPyApp *arg1 = (wxPyApp *) 0 ;
22683 bool result;
22684 PyObject * obj0 = 0 ;
22685 char *kwnames[] = {
22686 (char *) "self", NULL
22687 };
22688
22689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22691 if (SWIG_arg_fail(1)) SWIG_fail;
22692 {
22693 PyThreadState* __tstate = wxPyBeginAllowThreads();
22694 result = (bool)(arg1)->ProcessIdle();
22695
22696 wxPyEndAllowThreads(__tstate);
22697 if (PyErr_Occurred()) SWIG_fail;
22698 }
22699 {
22700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22701 }
22702 return resultobj;
22703 fail:
22704 return NULL;
22705 }
22706
22707
22708 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22709 PyObject *resultobj;
22710 wxPyApp *arg1 = (wxPyApp *) 0 ;
22711 wxWindow *arg2 = (wxWindow *) 0 ;
22712 wxIdleEvent *arg3 = 0 ;
22713 bool result;
22714 PyObject * obj0 = 0 ;
22715 PyObject * obj1 = 0 ;
22716 PyObject * obj2 = 0 ;
22717 char *kwnames[] = {
22718 (char *) "self",(char *) "win",(char *) "event", NULL
22719 };
22720
22721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22723 if (SWIG_arg_fail(1)) SWIG_fail;
22724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22725 if (SWIG_arg_fail(2)) SWIG_fail;
22726 {
22727 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22728 if (SWIG_arg_fail(3)) SWIG_fail;
22729 if (arg3 == NULL) {
22730 SWIG_null_ref("wxIdleEvent");
22731 }
22732 if (SWIG_arg_fail(3)) SWIG_fail;
22733 }
22734 {
22735 PyThreadState* __tstate = wxPyBeginAllowThreads();
22736 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22737
22738 wxPyEndAllowThreads(__tstate);
22739 if (PyErr_Occurred()) SWIG_fail;
22740 }
22741 {
22742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22743 }
22744 return resultobj;
22745 fail:
22746 return NULL;
22747 }
22748
22749
22750 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22751 PyObject *resultobj;
22752 wxPyApp *arg1 = (wxPyApp *) 0 ;
22753 bool result;
22754 PyObject * obj0 = 0 ;
22755 char *kwnames[] = {
22756 (char *) "self", NULL
22757 };
22758
22759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22761 if (SWIG_arg_fail(1)) SWIG_fail;
22762 {
22763 PyThreadState* __tstate = wxPyBeginAllowThreads();
22764 result = (bool)((wxPyApp const *)arg1)->IsActive();
22765
22766 wxPyEndAllowThreads(__tstate);
22767 if (PyErr_Occurred()) SWIG_fail;
22768 }
22769 {
22770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22771 }
22772 return resultobj;
22773 fail:
22774 return NULL;
22775 }
22776
22777
22778 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22779 PyObject *resultobj;
22780 wxPyApp *arg1 = (wxPyApp *) 0 ;
22781 wxWindow *arg2 = (wxWindow *) 0 ;
22782 PyObject * obj0 = 0 ;
22783 PyObject * obj1 = 0 ;
22784 char *kwnames[] = {
22785 (char *) "self",(char *) "win", NULL
22786 };
22787
22788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22790 if (SWIG_arg_fail(1)) SWIG_fail;
22791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22792 if (SWIG_arg_fail(2)) SWIG_fail;
22793 {
22794 PyThreadState* __tstate = wxPyBeginAllowThreads();
22795 (arg1)->SetTopWindow(arg2);
22796
22797 wxPyEndAllowThreads(__tstate);
22798 if (PyErr_Occurred()) SWIG_fail;
22799 }
22800 Py_INCREF(Py_None); resultobj = Py_None;
22801 return resultobj;
22802 fail:
22803 return NULL;
22804 }
22805
22806
22807 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22808 PyObject *resultobj;
22809 wxPyApp *arg1 = (wxPyApp *) 0 ;
22810 wxWindow *result;
22811 PyObject * obj0 = 0 ;
22812 char *kwnames[] = {
22813 (char *) "self", NULL
22814 };
22815
22816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22818 if (SWIG_arg_fail(1)) SWIG_fail;
22819 {
22820 PyThreadState* __tstate = wxPyBeginAllowThreads();
22821 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22822
22823 wxPyEndAllowThreads(__tstate);
22824 if (PyErr_Occurred()) SWIG_fail;
22825 }
22826 {
22827 resultobj = wxPyMake_wxObject(result, 0);
22828 }
22829 return resultobj;
22830 fail:
22831 return NULL;
22832 }
22833
22834
22835 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22836 PyObject *resultobj;
22837 wxPyApp *arg1 = (wxPyApp *) 0 ;
22838 bool arg2 ;
22839 PyObject * obj0 = 0 ;
22840 PyObject * obj1 = 0 ;
22841 char *kwnames[] = {
22842 (char *) "self",(char *) "flag", NULL
22843 };
22844
22845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22847 if (SWIG_arg_fail(1)) SWIG_fail;
22848 {
22849 arg2 = (bool)(SWIG_As_bool(obj1));
22850 if (SWIG_arg_fail(2)) SWIG_fail;
22851 }
22852 {
22853 PyThreadState* __tstate = wxPyBeginAllowThreads();
22854 (arg1)->SetExitOnFrameDelete(arg2);
22855
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 Py_INCREF(Py_None); resultobj = Py_None;
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22867 PyObject *resultobj;
22868 wxPyApp *arg1 = (wxPyApp *) 0 ;
22869 bool result;
22870 PyObject * obj0 = 0 ;
22871 char *kwnames[] = {
22872 (char *) "self", NULL
22873 };
22874
22875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22877 if (SWIG_arg_fail(1)) SWIG_fail;
22878 {
22879 PyThreadState* __tstate = wxPyBeginAllowThreads();
22880 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22881
22882 wxPyEndAllowThreads(__tstate);
22883 if (PyErr_Occurred()) SWIG_fail;
22884 }
22885 {
22886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22887 }
22888 return resultobj;
22889 fail:
22890 return NULL;
22891 }
22892
22893
22894 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22895 PyObject *resultobj;
22896 wxPyApp *arg1 = (wxPyApp *) 0 ;
22897 bool arg2 ;
22898 PyObject * obj0 = 0 ;
22899 PyObject * obj1 = 0 ;
22900 char *kwnames[] = {
22901 (char *) "self",(char *) "flag", NULL
22902 };
22903
22904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22906 if (SWIG_arg_fail(1)) SWIG_fail;
22907 {
22908 arg2 = (bool)(SWIG_As_bool(obj1));
22909 if (SWIG_arg_fail(2)) SWIG_fail;
22910 }
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 (arg1)->SetUseBestVisual(arg2);
22914
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 Py_INCREF(Py_None); resultobj = Py_None;
22919 return resultobj;
22920 fail:
22921 return NULL;
22922 }
22923
22924
22925 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22926 PyObject *resultobj;
22927 wxPyApp *arg1 = (wxPyApp *) 0 ;
22928 bool result;
22929 PyObject * obj0 = 0 ;
22930 char *kwnames[] = {
22931 (char *) "self", NULL
22932 };
22933
22934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22936 if (SWIG_arg_fail(1)) SWIG_fail;
22937 {
22938 PyThreadState* __tstate = wxPyBeginAllowThreads();
22939 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22940
22941 wxPyEndAllowThreads(__tstate);
22942 if (PyErr_Occurred()) SWIG_fail;
22943 }
22944 {
22945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22946 }
22947 return resultobj;
22948 fail:
22949 return NULL;
22950 }
22951
22952
22953 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22954 PyObject *resultobj;
22955 wxPyApp *arg1 = (wxPyApp *) 0 ;
22956 int arg2 ;
22957 PyObject * obj0 = 0 ;
22958 PyObject * obj1 = 0 ;
22959 char *kwnames[] = {
22960 (char *) "self",(char *) "mode", NULL
22961 };
22962
22963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22965 if (SWIG_arg_fail(1)) SWIG_fail;
22966 {
22967 arg2 = (int)(SWIG_As_int(obj1));
22968 if (SWIG_arg_fail(2)) SWIG_fail;
22969 }
22970 {
22971 PyThreadState* __tstate = wxPyBeginAllowThreads();
22972 (arg1)->SetPrintMode(arg2);
22973
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 Py_INCREF(Py_None); resultobj = Py_None;
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22985 PyObject *resultobj;
22986 wxPyApp *arg1 = (wxPyApp *) 0 ;
22987 int result;
22988 PyObject * obj0 = 0 ;
22989 char *kwnames[] = {
22990 (char *) "self", NULL
22991 };
22992
22993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22995 if (SWIG_arg_fail(1)) SWIG_fail;
22996 {
22997 PyThreadState* __tstate = wxPyBeginAllowThreads();
22998 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22999
23000 wxPyEndAllowThreads(__tstate);
23001 if (PyErr_Occurred()) SWIG_fail;
23002 }
23003 {
23004 resultobj = SWIG_From_int((int)(result));
23005 }
23006 return resultobj;
23007 fail:
23008 return NULL;
23009 }
23010
23011
23012 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23013 PyObject *resultobj;
23014 wxPyApp *arg1 = (wxPyApp *) 0 ;
23015 int arg2 ;
23016 PyObject * obj0 = 0 ;
23017 PyObject * obj1 = 0 ;
23018 char *kwnames[] = {
23019 (char *) "self",(char *) "mode", NULL
23020 };
23021
23022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23024 if (SWIG_arg_fail(1)) SWIG_fail;
23025 {
23026 arg2 = (int)(SWIG_As_int(obj1));
23027 if (SWIG_arg_fail(2)) SWIG_fail;
23028 }
23029 {
23030 PyThreadState* __tstate = wxPyBeginAllowThreads();
23031 (arg1)->SetAssertMode(arg2);
23032
23033 wxPyEndAllowThreads(__tstate);
23034 if (PyErr_Occurred()) SWIG_fail;
23035 }
23036 Py_INCREF(Py_None); resultobj = Py_None;
23037 return resultobj;
23038 fail:
23039 return NULL;
23040 }
23041
23042
23043 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23044 PyObject *resultobj;
23045 wxPyApp *arg1 = (wxPyApp *) 0 ;
23046 int result;
23047 PyObject * obj0 = 0 ;
23048 char *kwnames[] = {
23049 (char *) "self", NULL
23050 };
23051
23052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23054 if (SWIG_arg_fail(1)) SWIG_fail;
23055 {
23056 PyThreadState* __tstate = wxPyBeginAllowThreads();
23057 result = (int)(arg1)->GetAssertMode();
23058
23059 wxPyEndAllowThreads(__tstate);
23060 if (PyErr_Occurred()) SWIG_fail;
23061 }
23062 {
23063 resultobj = SWIG_From_int((int)(result));
23064 }
23065 return resultobj;
23066 fail:
23067 return NULL;
23068 }
23069
23070
23071 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23072 PyObject *resultobj;
23073 bool result;
23074 char *kwnames[] = {
23075 NULL
23076 };
23077
23078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23079 {
23080 PyThreadState* __tstate = wxPyBeginAllowThreads();
23081 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23082
23083 wxPyEndAllowThreads(__tstate);
23084 if (PyErr_Occurred()) SWIG_fail;
23085 }
23086 {
23087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23088 }
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23096 PyObject *resultobj;
23097 long result;
23098 char *kwnames[] = {
23099 NULL
23100 };
23101
23102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23103 {
23104 PyThreadState* __tstate = wxPyBeginAllowThreads();
23105 result = (long)wxPyApp::GetMacAboutMenuItemId();
23106
23107 wxPyEndAllowThreads(__tstate);
23108 if (PyErr_Occurred()) SWIG_fail;
23109 }
23110 {
23111 resultobj = SWIG_From_long((long)(result));
23112 }
23113 return resultobj;
23114 fail:
23115 return NULL;
23116 }
23117
23118
23119 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23120 PyObject *resultobj;
23121 long result;
23122 char *kwnames[] = {
23123 NULL
23124 };
23125
23126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23127 {
23128 PyThreadState* __tstate = wxPyBeginAllowThreads();
23129 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23130
23131 wxPyEndAllowThreads(__tstate);
23132 if (PyErr_Occurred()) SWIG_fail;
23133 }
23134 {
23135 resultobj = SWIG_From_long((long)(result));
23136 }
23137 return resultobj;
23138 fail:
23139 return NULL;
23140 }
23141
23142
23143 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23144 PyObject *resultobj;
23145 long result;
23146 char *kwnames[] = {
23147 NULL
23148 };
23149
23150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23151 {
23152 PyThreadState* __tstate = wxPyBeginAllowThreads();
23153 result = (long)wxPyApp::GetMacExitMenuItemId();
23154
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 {
23159 resultobj = SWIG_From_long((long)(result));
23160 }
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23168 PyObject *resultobj;
23169 wxString result;
23170 char *kwnames[] = {
23171 NULL
23172 };
23173
23174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23175 {
23176 PyThreadState* __tstate = wxPyBeginAllowThreads();
23177 result = wxPyApp::GetMacHelpMenuTitleName();
23178
23179 wxPyEndAllowThreads(__tstate);
23180 if (PyErr_Occurred()) SWIG_fail;
23181 }
23182 {
23183 #if wxUSE_UNICODE
23184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23185 #else
23186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23187 #endif
23188 }
23189 return resultobj;
23190 fail:
23191 return NULL;
23192 }
23193
23194
23195 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23196 PyObject *resultobj;
23197 bool arg1 ;
23198 PyObject * obj0 = 0 ;
23199 char *kwnames[] = {
23200 (char *) "val", NULL
23201 };
23202
23203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23204 {
23205 arg1 = (bool)(SWIG_As_bool(obj0));
23206 if (SWIG_arg_fail(1)) SWIG_fail;
23207 }
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23211
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 Py_INCREF(Py_None); resultobj = Py_None;
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23223 PyObject *resultobj;
23224 long arg1 ;
23225 PyObject * obj0 = 0 ;
23226 char *kwnames[] = {
23227 (char *) "val", NULL
23228 };
23229
23230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23231 {
23232 arg1 = (long)(SWIG_As_long(obj0));
23233 if (SWIG_arg_fail(1)) SWIG_fail;
23234 }
23235 {
23236 PyThreadState* __tstate = wxPyBeginAllowThreads();
23237 wxPyApp::SetMacAboutMenuItemId(arg1);
23238
23239 wxPyEndAllowThreads(__tstate);
23240 if (PyErr_Occurred()) SWIG_fail;
23241 }
23242 Py_INCREF(Py_None); resultobj = Py_None;
23243 return resultobj;
23244 fail:
23245 return NULL;
23246 }
23247
23248
23249 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23250 PyObject *resultobj;
23251 long arg1 ;
23252 PyObject * obj0 = 0 ;
23253 char *kwnames[] = {
23254 (char *) "val", NULL
23255 };
23256
23257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23258 {
23259 arg1 = (long)(SWIG_As_long(obj0));
23260 if (SWIG_arg_fail(1)) SWIG_fail;
23261 }
23262 {
23263 PyThreadState* __tstate = wxPyBeginAllowThreads();
23264 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23265
23266 wxPyEndAllowThreads(__tstate);
23267 if (PyErr_Occurred()) SWIG_fail;
23268 }
23269 Py_INCREF(Py_None); resultobj = Py_None;
23270 return resultobj;
23271 fail:
23272 return NULL;
23273 }
23274
23275
23276 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23277 PyObject *resultobj;
23278 long arg1 ;
23279 PyObject * obj0 = 0 ;
23280 char *kwnames[] = {
23281 (char *) "val", NULL
23282 };
23283
23284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23285 {
23286 arg1 = (long)(SWIG_As_long(obj0));
23287 if (SWIG_arg_fail(1)) SWIG_fail;
23288 }
23289 {
23290 PyThreadState* __tstate = wxPyBeginAllowThreads();
23291 wxPyApp::SetMacExitMenuItemId(arg1);
23292
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 Py_INCREF(Py_None); resultobj = Py_None;
23297 return resultobj;
23298 fail:
23299 return NULL;
23300 }
23301
23302
23303 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23304 PyObject *resultobj;
23305 wxString *arg1 = 0 ;
23306 bool temp1 = false ;
23307 PyObject * obj0 = 0 ;
23308 char *kwnames[] = {
23309 (char *) "val", NULL
23310 };
23311
23312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23313 {
23314 arg1 = wxString_in_helper(obj0);
23315 if (arg1 == NULL) SWIG_fail;
23316 temp1 = true;
23317 }
23318 {
23319 PyThreadState* __tstate = wxPyBeginAllowThreads();
23320 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23321
23322 wxPyEndAllowThreads(__tstate);
23323 if (PyErr_Occurred()) SWIG_fail;
23324 }
23325 Py_INCREF(Py_None); resultobj = Py_None;
23326 {
23327 if (temp1)
23328 delete arg1;
23329 }
23330 return resultobj;
23331 fail:
23332 {
23333 if (temp1)
23334 delete arg1;
23335 }
23336 return NULL;
23337 }
23338
23339
23340 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23341 PyObject *resultobj;
23342 wxPyApp *arg1 = (wxPyApp *) 0 ;
23343 PyObject * obj0 = 0 ;
23344 char *kwnames[] = {
23345 (char *) "self", NULL
23346 };
23347
23348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23350 if (SWIG_arg_fail(1)) SWIG_fail;
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 (arg1)->_BootstrapApp();
23354
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 Py_INCREF(Py_None); resultobj = Py_None;
23359 return resultobj;
23360 fail:
23361 return NULL;
23362 }
23363
23364
23365 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23366 PyObject *resultobj;
23367 int result;
23368 char *kwnames[] = {
23369 NULL
23370 };
23371
23372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23373 {
23374 PyThreadState* __tstate = wxPyBeginAllowThreads();
23375 result = (int)wxPyApp::GetComCtl32Version();
23376
23377 wxPyEndAllowThreads(__tstate);
23378 if (PyErr_Occurred()) SWIG_fail;
23379 }
23380 {
23381 resultobj = SWIG_From_int((int)(result));
23382 }
23383 return resultobj;
23384 fail:
23385 return NULL;
23386 }
23387
23388
23389 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23390 PyObject *obj;
23391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23392 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23393 Py_INCREF(obj);
23394 return Py_BuildValue((char *)"");
23395 }
23396 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23397 PyObject *resultobj;
23398 char *kwnames[] = {
23399 NULL
23400 };
23401
23402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 wxExit();
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_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj;
23419 bool result;
23420 char *kwnames[] = {
23421 NULL
23422 };
23423
23424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23425 {
23426 PyThreadState* __tstate = wxPyBeginAllowThreads();
23427 result = (bool)wxYield();
23428
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23434 }
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23442 PyObject *resultobj;
23443 bool result;
23444 char *kwnames[] = {
23445 NULL
23446 };
23447
23448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 result = (bool)wxYieldIfNeeded();
23452
23453 wxPyEndAllowThreads(__tstate);
23454 if (PyErr_Occurred()) SWIG_fail;
23455 }
23456 {
23457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23458 }
23459 return resultobj;
23460 fail:
23461 return NULL;
23462 }
23463
23464
23465 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23466 PyObject *resultobj;
23467 wxWindow *arg1 = (wxWindow *) NULL ;
23468 bool arg2 = (bool) false ;
23469 bool result;
23470 PyObject * obj0 = 0 ;
23471 PyObject * obj1 = 0 ;
23472 char *kwnames[] = {
23473 (char *) "win",(char *) "onlyIfNeeded", NULL
23474 };
23475
23476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23477 if (obj0) {
23478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23479 if (SWIG_arg_fail(1)) SWIG_fail;
23480 }
23481 if (obj1) {
23482 {
23483 arg2 = (bool)(SWIG_As_bool(obj1));
23484 if (SWIG_arg_fail(2)) SWIG_fail;
23485 }
23486 }
23487 {
23488 PyThreadState* __tstate = wxPyBeginAllowThreads();
23489 result = (bool)wxSafeYield(arg1,arg2);
23490
23491 wxPyEndAllowThreads(__tstate);
23492 if (PyErr_Occurred()) SWIG_fail;
23493 }
23494 {
23495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23496 }
23497 return resultobj;
23498 fail:
23499 return NULL;
23500 }
23501
23502
23503 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23504 PyObject *resultobj;
23505 char *kwnames[] = {
23506 NULL
23507 };
23508
23509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 wxWakeUpIdle();
23513
23514 wxPyEndAllowThreads(__tstate);
23515 if (PyErr_Occurred()) SWIG_fail;
23516 }
23517 Py_INCREF(Py_None); resultobj = Py_None;
23518 return resultobj;
23519 fail:
23520 return NULL;
23521 }
23522
23523
23524 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23525 PyObject *resultobj;
23526 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23527 wxEvent *arg2 = 0 ;
23528 PyObject * obj0 = 0 ;
23529 PyObject * obj1 = 0 ;
23530 char *kwnames[] = {
23531 (char *) "dest",(char *) "event", NULL
23532 };
23533
23534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23536 if (SWIG_arg_fail(1)) SWIG_fail;
23537 {
23538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23539 if (SWIG_arg_fail(2)) SWIG_fail;
23540 if (arg2 == NULL) {
23541 SWIG_null_ref("wxEvent");
23542 }
23543 if (SWIG_arg_fail(2)) SWIG_fail;
23544 }
23545 {
23546 PyThreadState* __tstate = wxPyBeginAllowThreads();
23547 wxPostEvent(arg1,*arg2);
23548
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 Py_INCREF(Py_None); resultobj = Py_None;
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj;
23561 char *kwnames[] = {
23562 NULL
23563 };
23564
23565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23566 {
23567 PyThreadState* __tstate = wxPyBeginAllowThreads();
23568 wxApp_CleanUp();
23569
23570 wxPyEndAllowThreads(__tstate);
23571 if (PyErr_Occurred()) SWIG_fail;
23572 }
23573 Py_INCREF(Py_None); resultobj = Py_None;
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23581 PyObject *resultobj;
23582 wxPyApp *result;
23583 char *kwnames[] = {
23584 NULL
23585 };
23586
23587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 result = (wxPyApp *)wxPyGetApp();
23591
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 {
23596 resultobj = wxPyMake_wxObject(result, 0);
23597 }
23598 return resultobj;
23599 fail:
23600 return NULL;
23601 }
23602
23603
23604 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23605 PyObject *resultobj;
23606 char *arg1 = (char *) 0 ;
23607 PyObject * obj0 = 0 ;
23608 char *kwnames[] = {
23609 (char *) "encoding", NULL
23610 };
23611
23612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23613 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23614 SWIG_arg_fail(1);SWIG_fail;
23615 }
23616 {
23617 PyThreadState* __tstate = wxPyBeginAllowThreads();
23618 wxSetDefaultPyEncoding((char const *)arg1);
23619
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 Py_INCREF(Py_None); resultobj = Py_None;
23624 return resultobj;
23625 fail:
23626 return NULL;
23627 }
23628
23629
23630 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23631 PyObject *resultobj;
23632 char *result;
23633 char *kwnames[] = {
23634 NULL
23635 };
23636
23637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23638 {
23639 PyThreadState* __tstate = wxPyBeginAllowThreads();
23640 result = (char *)wxGetDefaultPyEncoding();
23641
23642 wxPyEndAllowThreads(__tstate);
23643 if (PyErr_Occurred()) SWIG_fail;
23644 }
23645 resultobj = SWIG_FromCharPtr(result);
23646 return resultobj;
23647 fail:
23648 return NULL;
23649 }
23650
23651
23652 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23653 PyObject *resultobj;
23654 wxEventLoop *result;
23655 char *kwnames[] = {
23656 NULL
23657 };
23658
23659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = (wxEventLoop *)new wxEventLoop();
23663
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23668 return resultobj;
23669 fail:
23670 return NULL;
23671 }
23672
23673
23674 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23675 PyObject *resultobj;
23676 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23677 PyObject * obj0 = 0 ;
23678 char *kwnames[] = {
23679 (char *) "self", NULL
23680 };
23681
23682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23684 if (SWIG_arg_fail(1)) SWIG_fail;
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 delete arg1;
23688
23689 wxPyEndAllowThreads(__tstate);
23690 if (PyErr_Occurred()) SWIG_fail;
23691 }
23692 Py_INCREF(Py_None); resultobj = Py_None;
23693 return resultobj;
23694 fail:
23695 return NULL;
23696 }
23697
23698
23699 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23700 PyObject *resultobj;
23701 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23702 int result;
23703 PyObject * obj0 = 0 ;
23704 char *kwnames[] = {
23705 (char *) "self", NULL
23706 };
23707
23708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23710 if (SWIG_arg_fail(1)) SWIG_fail;
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = (int)(arg1)->Run();
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 {
23719 resultobj = SWIG_From_int((int)(result));
23720 }
23721 return resultobj;
23722 fail:
23723 return NULL;
23724 }
23725
23726
23727 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj;
23729 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23730 int arg2 = (int) 0 ;
23731 PyObject * obj0 = 0 ;
23732 PyObject * obj1 = 0 ;
23733 char *kwnames[] = {
23734 (char *) "self",(char *) "rc", NULL
23735 };
23736
23737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23739 if (SWIG_arg_fail(1)) SWIG_fail;
23740 if (obj1) {
23741 {
23742 arg2 = (int)(SWIG_As_int(obj1));
23743 if (SWIG_arg_fail(2)) SWIG_fail;
23744 }
23745 }
23746 {
23747 PyThreadState* __tstate = wxPyBeginAllowThreads();
23748 (arg1)->Exit(arg2);
23749
23750 wxPyEndAllowThreads(__tstate);
23751 if (PyErr_Occurred()) SWIG_fail;
23752 }
23753 Py_INCREF(Py_None); resultobj = Py_None;
23754 return resultobj;
23755 fail:
23756 return NULL;
23757 }
23758
23759
23760 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23761 PyObject *resultobj;
23762 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23763 bool result;
23764 PyObject * obj0 = 0 ;
23765 char *kwnames[] = {
23766 (char *) "self", NULL
23767 };
23768
23769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23771 if (SWIG_arg_fail(1)) SWIG_fail;
23772 {
23773 PyThreadState* __tstate = wxPyBeginAllowThreads();
23774 result = (bool)((wxEventLoop const *)arg1)->Pending();
23775
23776 wxPyEndAllowThreads(__tstate);
23777 if (PyErr_Occurred()) SWIG_fail;
23778 }
23779 {
23780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23781 }
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23789 PyObject *resultobj;
23790 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23791 bool result;
23792 PyObject * obj0 = 0 ;
23793 char *kwnames[] = {
23794 (char *) "self", NULL
23795 };
23796
23797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23799 if (SWIG_arg_fail(1)) SWIG_fail;
23800 {
23801 PyThreadState* __tstate = wxPyBeginAllowThreads();
23802 result = (bool)(arg1)->Dispatch();
23803
23804 wxPyEndAllowThreads(__tstate);
23805 if (PyErr_Occurred()) SWIG_fail;
23806 }
23807 {
23808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23809 }
23810 return resultobj;
23811 fail:
23812 return NULL;
23813 }
23814
23815
23816 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23817 PyObject *resultobj;
23818 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23819 bool result;
23820 PyObject * obj0 = 0 ;
23821 char *kwnames[] = {
23822 (char *) "self", NULL
23823 };
23824
23825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23827 if (SWIG_arg_fail(1)) SWIG_fail;
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23831
23832 wxPyEndAllowThreads(__tstate);
23833 if (PyErr_Occurred()) SWIG_fail;
23834 }
23835 {
23836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23837 }
23838 return resultobj;
23839 fail:
23840 return NULL;
23841 }
23842
23843
23844 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23845 PyObject *resultobj;
23846 wxEventLoop *result;
23847 char *kwnames[] = {
23848 NULL
23849 };
23850
23851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = (wxEventLoop *)wxEventLoop::GetActive();
23855
23856 wxPyEndAllowThreads(__tstate);
23857 if (PyErr_Occurred()) SWIG_fail;
23858 }
23859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23867 PyObject *resultobj;
23868 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23869 PyObject * obj0 = 0 ;
23870 char *kwnames[] = {
23871 (char *) "loop", NULL
23872 };
23873
23874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23876 if (SWIG_arg_fail(1)) SWIG_fail;
23877 {
23878 PyThreadState* __tstate = wxPyBeginAllowThreads();
23879 wxEventLoop::SetActive(arg1);
23880
23881 wxPyEndAllowThreads(__tstate);
23882 if (PyErr_Occurred()) SWIG_fail;
23883 }
23884 Py_INCREF(Py_None); resultobj = Py_None;
23885 return resultobj;
23886 fail:
23887 return NULL;
23888 }
23889
23890
23891 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23892 PyObject *obj;
23893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23894 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23895 Py_INCREF(obj);
23896 return Py_BuildValue((char *)"");
23897 }
23898 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23899 PyObject *resultobj;
23900 int arg1 = (int) 0 ;
23901 int arg2 = (int) 0 ;
23902 int arg3 = (int) 0 ;
23903 wxAcceleratorEntry *result;
23904 PyObject * obj0 = 0 ;
23905 PyObject * obj1 = 0 ;
23906 PyObject * obj2 = 0 ;
23907 char *kwnames[] = {
23908 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23909 };
23910
23911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23912 if (obj0) {
23913 {
23914 arg1 = (int)(SWIG_As_int(obj0));
23915 if (SWIG_arg_fail(1)) SWIG_fail;
23916 }
23917 }
23918 if (obj1) {
23919 {
23920 arg2 = (int)(SWIG_As_int(obj1));
23921 if (SWIG_arg_fail(2)) SWIG_fail;
23922 }
23923 }
23924 if (obj2) {
23925 {
23926 arg3 = (int)(SWIG_As_int(obj2));
23927 if (SWIG_arg_fail(3)) SWIG_fail;
23928 }
23929 }
23930 {
23931 PyThreadState* __tstate = wxPyBeginAllowThreads();
23932 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23933
23934 wxPyEndAllowThreads(__tstate);
23935 if (PyErr_Occurred()) SWIG_fail;
23936 }
23937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23938 return resultobj;
23939 fail:
23940 return NULL;
23941 }
23942
23943
23944 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23945 PyObject *resultobj;
23946 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23947 PyObject * obj0 = 0 ;
23948 char *kwnames[] = {
23949 (char *) "self", NULL
23950 };
23951
23952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23954 if (SWIG_arg_fail(1)) SWIG_fail;
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 delete arg1;
23958
23959 wxPyEndAllowThreads(__tstate);
23960 if (PyErr_Occurred()) SWIG_fail;
23961 }
23962 Py_INCREF(Py_None); resultobj = Py_None;
23963 return resultobj;
23964 fail:
23965 return NULL;
23966 }
23967
23968
23969 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23970 PyObject *resultobj;
23971 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23972 int arg2 ;
23973 int arg3 ;
23974 int arg4 ;
23975 PyObject * obj0 = 0 ;
23976 PyObject * obj1 = 0 ;
23977 PyObject * obj2 = 0 ;
23978 PyObject * obj3 = 0 ;
23979 char *kwnames[] = {
23980 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23981 };
23982
23983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23985 if (SWIG_arg_fail(1)) SWIG_fail;
23986 {
23987 arg2 = (int)(SWIG_As_int(obj1));
23988 if (SWIG_arg_fail(2)) SWIG_fail;
23989 }
23990 {
23991 arg3 = (int)(SWIG_As_int(obj2));
23992 if (SWIG_arg_fail(3)) SWIG_fail;
23993 }
23994 {
23995 arg4 = (int)(SWIG_As_int(obj3));
23996 if (SWIG_arg_fail(4)) SWIG_fail;
23997 }
23998 {
23999 PyThreadState* __tstate = wxPyBeginAllowThreads();
24000 (arg1)->Set(arg2,arg3,arg4);
24001
24002 wxPyEndAllowThreads(__tstate);
24003 if (PyErr_Occurred()) SWIG_fail;
24004 }
24005 Py_INCREF(Py_None); resultobj = Py_None;
24006 return resultobj;
24007 fail:
24008 return NULL;
24009 }
24010
24011
24012 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24013 PyObject *resultobj;
24014 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24015 int result;
24016 PyObject * obj0 = 0 ;
24017 char *kwnames[] = {
24018 (char *) "self", NULL
24019 };
24020
24021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24023 if (SWIG_arg_fail(1)) SWIG_fail;
24024 {
24025 PyThreadState* __tstate = wxPyBeginAllowThreads();
24026 result = (int)(arg1)->GetFlags();
24027
24028 wxPyEndAllowThreads(__tstate);
24029 if (PyErr_Occurred()) SWIG_fail;
24030 }
24031 {
24032 resultobj = SWIG_From_int((int)(result));
24033 }
24034 return resultobj;
24035 fail:
24036 return NULL;
24037 }
24038
24039
24040 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24041 PyObject *resultobj;
24042 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24043 int result;
24044 PyObject * obj0 = 0 ;
24045 char *kwnames[] = {
24046 (char *) "self", NULL
24047 };
24048
24049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24051 if (SWIG_arg_fail(1)) SWIG_fail;
24052 {
24053 PyThreadState* __tstate = wxPyBeginAllowThreads();
24054 result = (int)(arg1)->GetKeyCode();
24055
24056 wxPyEndAllowThreads(__tstate);
24057 if (PyErr_Occurred()) SWIG_fail;
24058 }
24059 {
24060 resultobj = SWIG_From_int((int)(result));
24061 }
24062 return resultobj;
24063 fail:
24064 return NULL;
24065 }
24066
24067
24068 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24069 PyObject *resultobj;
24070 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24071 int result;
24072 PyObject * obj0 = 0 ;
24073 char *kwnames[] = {
24074 (char *) "self", NULL
24075 };
24076
24077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24079 if (SWIG_arg_fail(1)) SWIG_fail;
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 result = (int)(arg1)->GetCommand();
24083
24084 wxPyEndAllowThreads(__tstate);
24085 if (PyErr_Occurred()) SWIG_fail;
24086 }
24087 {
24088 resultobj = SWIG_From_int((int)(result));
24089 }
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24097 PyObject *obj;
24098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24099 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24100 Py_INCREF(obj);
24101 return Py_BuildValue((char *)"");
24102 }
24103 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24104 PyObject *resultobj;
24105 int arg1 ;
24106 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24107 wxAcceleratorTable *result;
24108 PyObject * obj0 = 0 ;
24109 char *kwnames[] = {
24110 (char *) "n", NULL
24111 };
24112
24113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24114 {
24115 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24116 if (arg2) arg1 = PyList_Size(obj0);
24117 else arg1 = 0;
24118 }
24119 {
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24122
24123 wxPyEndAllowThreads(__tstate);
24124 if (PyErr_Occurred()) SWIG_fail;
24125 }
24126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24127 {
24128 delete [] arg2;
24129 }
24130 return resultobj;
24131 fail:
24132 {
24133 delete [] arg2;
24134 }
24135 return NULL;
24136 }
24137
24138
24139 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24140 PyObject *resultobj;
24141 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24142 PyObject * obj0 = 0 ;
24143 char *kwnames[] = {
24144 (char *) "self", NULL
24145 };
24146
24147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24149 if (SWIG_arg_fail(1)) SWIG_fail;
24150 {
24151 PyThreadState* __tstate = wxPyBeginAllowThreads();
24152 delete arg1;
24153
24154 wxPyEndAllowThreads(__tstate);
24155 if (PyErr_Occurred()) SWIG_fail;
24156 }
24157 Py_INCREF(Py_None); resultobj = Py_None;
24158 return resultobj;
24159 fail:
24160 return NULL;
24161 }
24162
24163
24164 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24165 PyObject *resultobj;
24166 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24167 bool result;
24168 PyObject * obj0 = 0 ;
24169 char *kwnames[] = {
24170 (char *) "self", NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(1)) SWIG_fail;
24176 {
24177 PyThreadState* __tstate = wxPyBeginAllowThreads();
24178 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24179
24180 wxPyEndAllowThreads(__tstate);
24181 if (PyErr_Occurred()) SWIG_fail;
24182 }
24183 {
24184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24185 }
24186 return resultobj;
24187 fail:
24188 return NULL;
24189 }
24190
24191
24192 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24193 PyObject *obj;
24194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24195 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24196 Py_INCREF(obj);
24197 return Py_BuildValue((char *)"");
24198 }
24199 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24200 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24201 return 1;
24202 }
24203
24204
24205 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24206 PyObject *pyobj;
24207
24208 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24209 return pyobj;
24210 }
24211
24212
24213 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24214 PyObject *resultobj;
24215 wxString *arg1 = 0 ;
24216 wxAcceleratorEntry *result;
24217 bool temp1 = false ;
24218 PyObject * obj0 = 0 ;
24219 char *kwnames[] = {
24220 (char *) "label", NULL
24221 };
24222
24223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24224 {
24225 arg1 = wxString_in_helper(obj0);
24226 if (arg1 == NULL) SWIG_fail;
24227 temp1 = true;
24228 }
24229 {
24230 PyThreadState* __tstate = wxPyBeginAllowThreads();
24231 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24232
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24237 {
24238 if (temp1)
24239 delete arg1;
24240 }
24241 return resultobj;
24242 fail:
24243 {
24244 if (temp1)
24245 delete arg1;
24246 }
24247 return NULL;
24248 }
24249
24250
24251 static int _wrap_PanelNameStr_set(PyObject *) {
24252 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24253 return 1;
24254 }
24255
24256
24257 static PyObject *_wrap_PanelNameStr_get(void) {
24258 PyObject *pyobj;
24259
24260 {
24261 #if wxUSE_UNICODE
24262 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24263 #else
24264 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24265 #endif
24266 }
24267 return pyobj;
24268 }
24269
24270
24271 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24272 PyObject *resultobj;
24273 wxVisualAttributes *result;
24274 char *kwnames[] = {
24275 NULL
24276 };
24277
24278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (wxVisualAttributes *)new_wxVisualAttributes();
24282
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24287 return resultobj;
24288 fail:
24289 return NULL;
24290 }
24291
24292
24293 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24294 PyObject *resultobj;
24295 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24296 PyObject * obj0 = 0 ;
24297 char *kwnames[] = {
24298 (char *) "self", NULL
24299 };
24300
24301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24303 if (SWIG_arg_fail(1)) SWIG_fail;
24304 {
24305 PyThreadState* __tstate = wxPyBeginAllowThreads();
24306 delete_wxVisualAttributes(arg1);
24307
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 Py_INCREF(Py_None); resultobj = Py_None;
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24319 PyObject *resultobj;
24320 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24321 wxFont *arg2 = (wxFont *) 0 ;
24322 PyObject * obj0 = 0 ;
24323 PyObject * obj1 = 0 ;
24324 char *kwnames[] = {
24325 (char *) "self",(char *) "font", NULL
24326 };
24327
24328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24330 if (SWIG_arg_fail(1)) SWIG_fail;
24331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24332 if (SWIG_arg_fail(2)) SWIG_fail;
24333 if (arg1) (arg1)->font = *arg2;
24334
24335 Py_INCREF(Py_None); resultobj = Py_None;
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24343 PyObject *resultobj;
24344 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24345 wxFont *result;
24346 PyObject * obj0 = 0 ;
24347 char *kwnames[] = {
24348 (char *) "self", NULL
24349 };
24350
24351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24353 if (SWIG_arg_fail(1)) SWIG_fail;
24354 result = (wxFont *)& ((arg1)->font);
24355
24356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj;
24365 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24366 wxColour *arg2 = (wxColour *) 0 ;
24367 PyObject * obj0 = 0 ;
24368 PyObject * obj1 = 0 ;
24369 char *kwnames[] = {
24370 (char *) "self",(char *) "colFg", NULL
24371 };
24372
24373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24375 if (SWIG_arg_fail(1)) SWIG_fail;
24376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24377 if (SWIG_arg_fail(2)) SWIG_fail;
24378 if (arg1) (arg1)->colFg = *arg2;
24379
24380 Py_INCREF(Py_None); resultobj = Py_None;
24381 return resultobj;
24382 fail:
24383 return NULL;
24384 }
24385
24386
24387 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24388 PyObject *resultobj;
24389 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24390 wxColour *result;
24391 PyObject * obj0 = 0 ;
24392 char *kwnames[] = {
24393 (char *) "self", NULL
24394 };
24395
24396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24398 if (SWIG_arg_fail(1)) SWIG_fail;
24399 result = (wxColour *)& ((arg1)->colFg);
24400
24401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj;
24410 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24411 wxColour *arg2 = (wxColour *) 0 ;
24412 PyObject * obj0 = 0 ;
24413 PyObject * obj1 = 0 ;
24414 char *kwnames[] = {
24415 (char *) "self",(char *) "colBg", NULL
24416 };
24417
24418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24420 if (SWIG_arg_fail(1)) SWIG_fail;
24421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 if (arg1) (arg1)->colBg = *arg2;
24424
24425 Py_INCREF(Py_None); resultobj = Py_None;
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24433 PyObject *resultobj;
24434 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24435 wxColour *result;
24436 PyObject * obj0 = 0 ;
24437 char *kwnames[] = {
24438 (char *) "self", NULL
24439 };
24440
24441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24443 if (SWIG_arg_fail(1)) SWIG_fail;
24444 result = (wxColour *)& ((arg1)->colBg);
24445
24446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24447 return resultobj;
24448 fail:
24449 return NULL;
24450 }
24451
24452
24453 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24454 PyObject *obj;
24455 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24456 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24457 Py_INCREF(obj);
24458 return Py_BuildValue((char *)"");
24459 }
24460 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24461 PyObject *resultobj;
24462 wxWindow *arg1 = (wxWindow *) 0 ;
24463 int arg2 = (int) (int)-1 ;
24464 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24465 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24466 wxSize const &arg4_defvalue = wxDefaultSize ;
24467 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24468 long arg5 = (long) 0 ;
24469 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24470 wxString *arg6 = (wxString *) &arg6_defvalue ;
24471 wxWindow *result;
24472 wxPoint temp3 ;
24473 wxSize temp4 ;
24474 bool temp6 = false ;
24475 PyObject * obj0 = 0 ;
24476 PyObject * obj1 = 0 ;
24477 PyObject * obj2 = 0 ;
24478 PyObject * obj3 = 0 ;
24479 PyObject * obj4 = 0 ;
24480 PyObject * obj5 = 0 ;
24481 char *kwnames[] = {
24482 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24483 };
24484
24485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24487 if (SWIG_arg_fail(1)) SWIG_fail;
24488 if (obj1) {
24489 {
24490 arg2 = (int const)(SWIG_As_int(obj1));
24491 if (SWIG_arg_fail(2)) SWIG_fail;
24492 }
24493 }
24494 if (obj2) {
24495 {
24496 arg3 = &temp3;
24497 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24498 }
24499 }
24500 if (obj3) {
24501 {
24502 arg4 = &temp4;
24503 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24504 }
24505 }
24506 if (obj4) {
24507 {
24508 arg5 = (long)(SWIG_As_long(obj4));
24509 if (SWIG_arg_fail(5)) SWIG_fail;
24510 }
24511 }
24512 if (obj5) {
24513 {
24514 arg6 = wxString_in_helper(obj5);
24515 if (arg6 == NULL) SWIG_fail;
24516 temp6 = true;
24517 }
24518 }
24519 {
24520 if (!wxPyCheckForApp()) SWIG_fail;
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24523
24524 wxPyEndAllowThreads(__tstate);
24525 if (PyErr_Occurred()) SWIG_fail;
24526 }
24527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24528 {
24529 if (temp6)
24530 delete arg6;
24531 }
24532 return resultobj;
24533 fail:
24534 {
24535 if (temp6)
24536 delete arg6;
24537 }
24538 return NULL;
24539 }
24540
24541
24542 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24543 PyObject *resultobj;
24544 wxWindow *result;
24545 char *kwnames[] = {
24546 NULL
24547 };
24548
24549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24550 {
24551 if (!wxPyCheckForApp()) SWIG_fail;
24552 PyThreadState* __tstate = wxPyBeginAllowThreads();
24553 result = (wxWindow *)new wxWindow();
24554
24555 wxPyEndAllowThreads(__tstate);
24556 if (PyErr_Occurred()) SWIG_fail;
24557 }
24558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24559 return resultobj;
24560 fail:
24561 return NULL;
24562 }
24563
24564
24565 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24566 PyObject *resultobj;
24567 wxWindow *arg1 = (wxWindow *) 0 ;
24568 wxWindow *arg2 = (wxWindow *) 0 ;
24569 int arg3 = (int) (int)-1 ;
24570 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24571 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24572 wxSize const &arg5_defvalue = wxDefaultSize ;
24573 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24574 long arg6 = (long) 0 ;
24575 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24576 wxString *arg7 = (wxString *) &arg7_defvalue ;
24577 bool result;
24578 wxPoint temp4 ;
24579 wxSize temp5 ;
24580 bool temp7 = false ;
24581 PyObject * obj0 = 0 ;
24582 PyObject * obj1 = 0 ;
24583 PyObject * obj2 = 0 ;
24584 PyObject * obj3 = 0 ;
24585 PyObject * obj4 = 0 ;
24586 PyObject * obj5 = 0 ;
24587 PyObject * obj6 = 0 ;
24588 char *kwnames[] = {
24589 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24590 };
24591
24592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24594 if (SWIG_arg_fail(1)) SWIG_fail;
24595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24596 if (SWIG_arg_fail(2)) SWIG_fail;
24597 if (obj2) {
24598 {
24599 arg3 = (int const)(SWIG_As_int(obj2));
24600 if (SWIG_arg_fail(3)) SWIG_fail;
24601 }
24602 }
24603 if (obj3) {
24604 {
24605 arg4 = &temp4;
24606 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24607 }
24608 }
24609 if (obj4) {
24610 {
24611 arg5 = &temp5;
24612 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24613 }
24614 }
24615 if (obj5) {
24616 {
24617 arg6 = (long)(SWIG_As_long(obj5));
24618 if (SWIG_arg_fail(6)) SWIG_fail;
24619 }
24620 }
24621 if (obj6) {
24622 {
24623 arg7 = wxString_in_helper(obj6);
24624 if (arg7 == NULL) SWIG_fail;
24625 temp7 = true;
24626 }
24627 }
24628 {
24629 PyThreadState* __tstate = wxPyBeginAllowThreads();
24630 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24631
24632 wxPyEndAllowThreads(__tstate);
24633 if (PyErr_Occurred()) SWIG_fail;
24634 }
24635 {
24636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24637 }
24638 {
24639 if (temp7)
24640 delete arg7;
24641 }
24642 return resultobj;
24643 fail:
24644 {
24645 if (temp7)
24646 delete arg7;
24647 }
24648 return NULL;
24649 }
24650
24651
24652 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj;
24654 wxWindow *arg1 = (wxWindow *) 0 ;
24655 bool arg2 = (bool) false ;
24656 bool result;
24657 PyObject * obj0 = 0 ;
24658 PyObject * obj1 = 0 ;
24659 char *kwnames[] = {
24660 (char *) "self",(char *) "force", NULL
24661 };
24662
24663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24665 if (SWIG_arg_fail(1)) SWIG_fail;
24666 if (obj1) {
24667 {
24668 arg2 = (bool)(SWIG_As_bool(obj1));
24669 if (SWIG_arg_fail(2)) SWIG_fail;
24670 }
24671 }
24672 {
24673 PyThreadState* __tstate = wxPyBeginAllowThreads();
24674 result = (bool)(arg1)->Close(arg2);
24675
24676 wxPyEndAllowThreads(__tstate);
24677 if (PyErr_Occurred()) SWIG_fail;
24678 }
24679 {
24680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24681 }
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24689 PyObject *resultobj;
24690 wxWindow *arg1 = (wxWindow *) 0 ;
24691 bool result;
24692 PyObject * obj0 = 0 ;
24693 char *kwnames[] = {
24694 (char *) "self", NULL
24695 };
24696
24697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24699 if (SWIG_arg_fail(1)) SWIG_fail;
24700 {
24701 PyThreadState* __tstate = wxPyBeginAllowThreads();
24702 result = (bool)(arg1)->Destroy();
24703
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 {
24708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24709 }
24710 return resultobj;
24711 fail:
24712 return NULL;
24713 }
24714
24715
24716 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24717 PyObject *resultobj;
24718 wxWindow *arg1 = (wxWindow *) 0 ;
24719 bool result;
24720 PyObject * obj0 = 0 ;
24721 char *kwnames[] = {
24722 (char *) "self", NULL
24723 };
24724
24725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24727 if (SWIG_arg_fail(1)) SWIG_fail;
24728 {
24729 PyThreadState* __tstate = wxPyBeginAllowThreads();
24730 result = (bool)(arg1)->DestroyChildren();
24731
24732 wxPyEndAllowThreads(__tstate);
24733 if (PyErr_Occurred()) SWIG_fail;
24734 }
24735 {
24736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24737 }
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24745 PyObject *resultobj;
24746 wxWindow *arg1 = (wxWindow *) 0 ;
24747 bool result;
24748 PyObject * obj0 = 0 ;
24749 char *kwnames[] = {
24750 (char *) "self", NULL
24751 };
24752
24753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24755 if (SWIG_arg_fail(1)) SWIG_fail;
24756 {
24757 PyThreadState* __tstate = wxPyBeginAllowThreads();
24758 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24759
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 {
24764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24765 }
24766 return resultobj;
24767 fail:
24768 return NULL;
24769 }
24770
24771
24772 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24773 PyObject *resultobj;
24774 wxWindow *arg1 = (wxWindow *) 0 ;
24775 wxString *arg2 = 0 ;
24776 bool temp2 = false ;
24777 PyObject * obj0 = 0 ;
24778 PyObject * obj1 = 0 ;
24779 char *kwnames[] = {
24780 (char *) "self",(char *) "title", NULL
24781 };
24782
24783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24785 if (SWIG_arg_fail(1)) SWIG_fail;
24786 {
24787 arg2 = wxString_in_helper(obj1);
24788 if (arg2 == NULL) SWIG_fail;
24789 temp2 = true;
24790 }
24791 {
24792 PyThreadState* __tstate = wxPyBeginAllowThreads();
24793 (arg1)->SetTitle((wxString const &)*arg2);
24794
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 Py_INCREF(Py_None); resultobj = Py_None;
24799 {
24800 if (temp2)
24801 delete arg2;
24802 }
24803 return resultobj;
24804 fail:
24805 {
24806 if (temp2)
24807 delete arg2;
24808 }
24809 return NULL;
24810 }
24811
24812
24813 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24814 PyObject *resultobj;
24815 wxWindow *arg1 = (wxWindow *) 0 ;
24816 wxString result;
24817 PyObject * obj0 = 0 ;
24818 char *kwnames[] = {
24819 (char *) "self", NULL
24820 };
24821
24822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24824 if (SWIG_arg_fail(1)) SWIG_fail;
24825 {
24826 PyThreadState* __tstate = wxPyBeginAllowThreads();
24827 result = ((wxWindow const *)arg1)->GetTitle();
24828
24829 wxPyEndAllowThreads(__tstate);
24830 if (PyErr_Occurred()) SWIG_fail;
24831 }
24832 {
24833 #if wxUSE_UNICODE
24834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24835 #else
24836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24837 #endif
24838 }
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24846 PyObject *resultobj;
24847 wxWindow *arg1 = (wxWindow *) 0 ;
24848 wxString *arg2 = 0 ;
24849 bool temp2 = false ;
24850 PyObject * obj0 = 0 ;
24851 PyObject * obj1 = 0 ;
24852 char *kwnames[] = {
24853 (char *) "self",(char *) "label", NULL
24854 };
24855
24856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24858 if (SWIG_arg_fail(1)) SWIG_fail;
24859 {
24860 arg2 = wxString_in_helper(obj1);
24861 if (arg2 == NULL) SWIG_fail;
24862 temp2 = true;
24863 }
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 (arg1)->SetLabel((wxString const &)*arg2);
24867
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 Py_INCREF(Py_None); resultobj = Py_None;
24872 {
24873 if (temp2)
24874 delete arg2;
24875 }
24876 return resultobj;
24877 fail:
24878 {
24879 if (temp2)
24880 delete arg2;
24881 }
24882 return NULL;
24883 }
24884
24885
24886 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24887 PyObject *resultobj;
24888 wxWindow *arg1 = (wxWindow *) 0 ;
24889 wxString result;
24890 PyObject * obj0 = 0 ;
24891 char *kwnames[] = {
24892 (char *) "self", NULL
24893 };
24894
24895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24897 if (SWIG_arg_fail(1)) SWIG_fail;
24898 {
24899 PyThreadState* __tstate = wxPyBeginAllowThreads();
24900 result = ((wxWindow const *)arg1)->GetLabel();
24901
24902 wxPyEndAllowThreads(__tstate);
24903 if (PyErr_Occurred()) SWIG_fail;
24904 }
24905 {
24906 #if wxUSE_UNICODE
24907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24908 #else
24909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24910 #endif
24911 }
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24919 PyObject *resultobj;
24920 wxWindow *arg1 = (wxWindow *) 0 ;
24921 wxString *arg2 = 0 ;
24922 bool temp2 = false ;
24923 PyObject * obj0 = 0 ;
24924 PyObject * obj1 = 0 ;
24925 char *kwnames[] = {
24926 (char *) "self",(char *) "name", NULL
24927 };
24928
24929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24931 if (SWIG_arg_fail(1)) SWIG_fail;
24932 {
24933 arg2 = wxString_in_helper(obj1);
24934 if (arg2 == NULL) SWIG_fail;
24935 temp2 = true;
24936 }
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 (arg1)->SetName((wxString const &)*arg2);
24940
24941 wxPyEndAllowThreads(__tstate);
24942 if (PyErr_Occurred()) SWIG_fail;
24943 }
24944 Py_INCREF(Py_None); resultobj = Py_None;
24945 {
24946 if (temp2)
24947 delete arg2;
24948 }
24949 return resultobj;
24950 fail:
24951 {
24952 if (temp2)
24953 delete arg2;
24954 }
24955 return NULL;
24956 }
24957
24958
24959 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24960 PyObject *resultobj;
24961 wxWindow *arg1 = (wxWindow *) 0 ;
24962 wxString result;
24963 PyObject * obj0 = 0 ;
24964 char *kwnames[] = {
24965 (char *) "self", NULL
24966 };
24967
24968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24970 if (SWIG_arg_fail(1)) SWIG_fail;
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 result = ((wxWindow const *)arg1)->GetName();
24974
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 {
24979 #if wxUSE_UNICODE
24980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24981 #else
24982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24983 #endif
24984 }
24985 return resultobj;
24986 fail:
24987 return NULL;
24988 }
24989
24990
24991 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24992 PyObject *resultobj;
24993 wxWindow *arg1 = (wxWindow *) 0 ;
24994 wxWindowVariant arg2 ;
24995 PyObject * obj0 = 0 ;
24996 PyObject * obj1 = 0 ;
24997 char *kwnames[] = {
24998 (char *) "self",(char *) "variant", NULL
24999 };
25000
25001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25003 if (SWIG_arg_fail(1)) SWIG_fail;
25004 {
25005 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25006 if (SWIG_arg_fail(2)) SWIG_fail;
25007 }
25008 {
25009 PyThreadState* __tstate = wxPyBeginAllowThreads();
25010 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25011
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 Py_INCREF(Py_None); resultobj = Py_None;
25016 return resultobj;
25017 fail:
25018 return NULL;
25019 }
25020
25021
25022 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj;
25024 wxWindow *arg1 = (wxWindow *) 0 ;
25025 wxWindowVariant result;
25026 PyObject * obj0 = 0 ;
25027 char *kwnames[] = {
25028 (char *) "self", NULL
25029 };
25030
25031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25033 if (SWIG_arg_fail(1)) SWIG_fail;
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25037
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 resultobj = SWIG_From_int((result));
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25049 PyObject *resultobj;
25050 wxWindow *arg1 = (wxWindow *) 0 ;
25051 int arg2 ;
25052 PyObject * obj0 = 0 ;
25053 PyObject * obj1 = 0 ;
25054 char *kwnames[] = {
25055 (char *) "self",(char *) "winid", NULL
25056 };
25057
25058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25060 if (SWIG_arg_fail(1)) SWIG_fail;
25061 {
25062 arg2 = (int)(SWIG_As_int(obj1));
25063 if (SWIG_arg_fail(2)) SWIG_fail;
25064 }
25065 {
25066 PyThreadState* __tstate = wxPyBeginAllowThreads();
25067 (arg1)->SetId(arg2);
25068
25069 wxPyEndAllowThreads(__tstate);
25070 if (PyErr_Occurred()) SWIG_fail;
25071 }
25072 Py_INCREF(Py_None); resultobj = Py_None;
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25080 PyObject *resultobj;
25081 wxWindow *arg1 = (wxWindow *) 0 ;
25082 int result;
25083 PyObject * obj0 = 0 ;
25084 char *kwnames[] = {
25085 (char *) "self", NULL
25086 };
25087
25088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25090 if (SWIG_arg_fail(1)) SWIG_fail;
25091 {
25092 PyThreadState* __tstate = wxPyBeginAllowThreads();
25093 result = (int)((wxWindow const *)arg1)->GetId();
25094
25095 wxPyEndAllowThreads(__tstate);
25096 if (PyErr_Occurred()) SWIG_fail;
25097 }
25098 {
25099 resultobj = SWIG_From_int((int)(result));
25100 }
25101 return resultobj;
25102 fail:
25103 return NULL;
25104 }
25105
25106
25107 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25108 PyObject *resultobj;
25109 int result;
25110 char *kwnames[] = {
25111 NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 result = (int)wxWindow::NewControlId();
25118
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 {
25123 resultobj = SWIG_From_int((int)(result));
25124 }
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25132 PyObject *resultobj;
25133 int arg1 ;
25134 int result;
25135 PyObject * obj0 = 0 ;
25136 char *kwnames[] = {
25137 (char *) "winid", NULL
25138 };
25139
25140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25141 {
25142 arg1 = (int)(SWIG_As_int(obj0));
25143 if (SWIG_arg_fail(1)) SWIG_fail;
25144 }
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = (int)wxWindow::NextControlId(arg1);
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 resultobj = SWIG_From_int((int)(result));
25154 }
25155 return resultobj;
25156 fail:
25157 return NULL;
25158 }
25159
25160
25161 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25162 PyObject *resultobj;
25163 int arg1 ;
25164 int result;
25165 PyObject * obj0 = 0 ;
25166 char *kwnames[] = {
25167 (char *) "winid", NULL
25168 };
25169
25170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25171 {
25172 arg1 = (int)(SWIG_As_int(obj0));
25173 if (SWIG_arg_fail(1)) SWIG_fail;
25174 }
25175 {
25176 PyThreadState* __tstate = wxPyBeginAllowThreads();
25177 result = (int)wxWindow::PrevControlId(arg1);
25178
25179 wxPyEndAllowThreads(__tstate);
25180 if (PyErr_Occurred()) SWIG_fail;
25181 }
25182 {
25183 resultobj = SWIG_From_int((int)(result));
25184 }
25185 return resultobj;
25186 fail:
25187 return NULL;
25188 }
25189
25190
25191 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25192 PyObject *resultobj;
25193 wxWindow *arg1 = (wxWindow *) 0 ;
25194 wxSize *arg2 = 0 ;
25195 wxSize temp2 ;
25196 PyObject * obj0 = 0 ;
25197 PyObject * obj1 = 0 ;
25198 char *kwnames[] = {
25199 (char *) "self",(char *) "size", NULL
25200 };
25201
25202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25204 if (SWIG_arg_fail(1)) SWIG_fail;
25205 {
25206 arg2 = &temp2;
25207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25208 }
25209 {
25210 PyThreadState* __tstate = wxPyBeginAllowThreads();
25211 (arg1)->SetSize((wxSize const &)*arg2);
25212
25213 wxPyEndAllowThreads(__tstate);
25214 if (PyErr_Occurred()) SWIG_fail;
25215 }
25216 Py_INCREF(Py_None); resultobj = Py_None;
25217 return resultobj;
25218 fail:
25219 return NULL;
25220 }
25221
25222
25223 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25224 PyObject *resultobj;
25225 wxWindow *arg1 = (wxWindow *) 0 ;
25226 int arg2 ;
25227 int arg3 ;
25228 int arg4 ;
25229 int arg5 ;
25230 int arg6 = (int) wxSIZE_AUTO ;
25231 PyObject * obj0 = 0 ;
25232 PyObject * obj1 = 0 ;
25233 PyObject * obj2 = 0 ;
25234 PyObject * obj3 = 0 ;
25235 PyObject * obj4 = 0 ;
25236 PyObject * obj5 = 0 ;
25237 char *kwnames[] = {
25238 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25239 };
25240
25241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25243 if (SWIG_arg_fail(1)) SWIG_fail;
25244 {
25245 arg2 = (int)(SWIG_As_int(obj1));
25246 if (SWIG_arg_fail(2)) SWIG_fail;
25247 }
25248 {
25249 arg3 = (int)(SWIG_As_int(obj2));
25250 if (SWIG_arg_fail(3)) SWIG_fail;
25251 }
25252 {
25253 arg4 = (int)(SWIG_As_int(obj3));
25254 if (SWIG_arg_fail(4)) SWIG_fail;
25255 }
25256 {
25257 arg5 = (int)(SWIG_As_int(obj4));
25258 if (SWIG_arg_fail(5)) SWIG_fail;
25259 }
25260 if (obj5) {
25261 {
25262 arg6 = (int)(SWIG_As_int(obj5));
25263 if (SWIG_arg_fail(6)) SWIG_fail;
25264 }
25265 }
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25269
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 Py_INCREF(Py_None); resultobj = Py_None;
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj;
25282 wxWindow *arg1 = (wxWindow *) 0 ;
25283 wxRect *arg2 = 0 ;
25284 int arg3 = (int) wxSIZE_AUTO ;
25285 wxRect temp2 ;
25286 PyObject * obj0 = 0 ;
25287 PyObject * obj1 = 0 ;
25288 PyObject * obj2 = 0 ;
25289 char *kwnames[] = {
25290 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25291 };
25292
25293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25295 if (SWIG_arg_fail(1)) SWIG_fail;
25296 {
25297 arg2 = &temp2;
25298 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25299 }
25300 if (obj2) {
25301 {
25302 arg3 = (int)(SWIG_As_int(obj2));
25303 if (SWIG_arg_fail(3)) SWIG_fail;
25304 }
25305 }
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25309
25310 wxPyEndAllowThreads(__tstate);
25311 if (PyErr_Occurred()) SWIG_fail;
25312 }
25313 Py_INCREF(Py_None); resultobj = Py_None;
25314 return resultobj;
25315 fail:
25316 return NULL;
25317 }
25318
25319
25320 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25321 PyObject *resultobj;
25322 wxWindow *arg1 = (wxWindow *) 0 ;
25323 int arg2 ;
25324 int arg3 ;
25325 PyObject * obj0 = 0 ;
25326 PyObject * obj1 = 0 ;
25327 PyObject * obj2 = 0 ;
25328 char *kwnames[] = {
25329 (char *) "self",(char *) "width",(char *) "height", NULL
25330 };
25331
25332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25334 if (SWIG_arg_fail(1)) SWIG_fail;
25335 {
25336 arg2 = (int)(SWIG_As_int(obj1));
25337 if (SWIG_arg_fail(2)) SWIG_fail;
25338 }
25339 {
25340 arg3 = (int)(SWIG_As_int(obj2));
25341 if (SWIG_arg_fail(3)) SWIG_fail;
25342 }
25343 {
25344 PyThreadState* __tstate = wxPyBeginAllowThreads();
25345 (arg1)->SetSize(arg2,arg3);
25346
25347 wxPyEndAllowThreads(__tstate);
25348 if (PyErr_Occurred()) SWIG_fail;
25349 }
25350 Py_INCREF(Py_None); resultobj = Py_None;
25351 return resultobj;
25352 fail:
25353 return NULL;
25354 }
25355
25356
25357 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25358 PyObject *resultobj;
25359 wxWindow *arg1 = (wxWindow *) 0 ;
25360 wxPoint *arg2 = 0 ;
25361 int arg3 = (int) wxSIZE_USE_EXISTING ;
25362 wxPoint temp2 ;
25363 PyObject * obj0 = 0 ;
25364 PyObject * obj1 = 0 ;
25365 PyObject * obj2 = 0 ;
25366 char *kwnames[] = {
25367 (char *) "self",(char *) "pt",(char *) "flags", NULL
25368 };
25369
25370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25372 if (SWIG_arg_fail(1)) SWIG_fail;
25373 {
25374 arg2 = &temp2;
25375 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25376 }
25377 if (obj2) {
25378 {
25379 arg3 = (int)(SWIG_As_int(obj2));
25380 if (SWIG_arg_fail(3)) SWIG_fail;
25381 }
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 (arg1)->Move((wxPoint const &)*arg2,arg3);
25386
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 Py_INCREF(Py_None); resultobj = Py_None;
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25398 PyObject *resultobj;
25399 wxWindow *arg1 = (wxWindow *) 0 ;
25400 int arg2 ;
25401 int arg3 ;
25402 int arg4 = (int) wxSIZE_USE_EXISTING ;
25403 PyObject * obj0 = 0 ;
25404 PyObject * obj1 = 0 ;
25405 PyObject * obj2 = 0 ;
25406 PyObject * obj3 = 0 ;
25407 char *kwnames[] = {
25408 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25409 };
25410
25411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25413 if (SWIG_arg_fail(1)) SWIG_fail;
25414 {
25415 arg2 = (int)(SWIG_As_int(obj1));
25416 if (SWIG_arg_fail(2)) SWIG_fail;
25417 }
25418 {
25419 arg3 = (int)(SWIG_As_int(obj2));
25420 if (SWIG_arg_fail(3)) SWIG_fail;
25421 }
25422 if (obj3) {
25423 {
25424 arg4 = (int)(SWIG_As_int(obj3));
25425 if (SWIG_arg_fail(4)) SWIG_fail;
25426 }
25427 }
25428 {
25429 PyThreadState* __tstate = wxPyBeginAllowThreads();
25430 (arg1)->Move(arg2,arg3,arg4);
25431
25432 wxPyEndAllowThreads(__tstate);
25433 if (PyErr_Occurred()) SWIG_fail;
25434 }
25435 Py_INCREF(Py_None); resultobj = Py_None;
25436 return resultobj;
25437 fail:
25438 return NULL;
25439 }
25440
25441
25442 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25443 PyObject *resultobj;
25444 wxWindow *arg1 = (wxWindow *) 0 ;
25445 wxSize const &arg2_defvalue = wxDefaultSize ;
25446 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25447 wxSize temp2 ;
25448 PyObject * obj0 = 0 ;
25449 PyObject * obj1 = 0 ;
25450 char *kwnames[] = {
25451 (char *) "self",(char *) "size", NULL
25452 };
25453
25454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25456 if (SWIG_arg_fail(1)) SWIG_fail;
25457 if (obj1) {
25458 {
25459 arg2 = &temp2;
25460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25461 }
25462 }
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25466
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 Py_INCREF(Py_None); resultobj = Py_None;
25471 return resultobj;
25472 fail:
25473 return NULL;
25474 }
25475
25476
25477 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25478 PyObject *resultobj;
25479 wxWindow *arg1 = (wxWindow *) 0 ;
25480 PyObject * obj0 = 0 ;
25481 char *kwnames[] = {
25482 (char *) "self", NULL
25483 };
25484
25485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25487 if (SWIG_arg_fail(1)) SWIG_fail;
25488 {
25489 PyThreadState* __tstate = wxPyBeginAllowThreads();
25490 (arg1)->Raise();
25491
25492 wxPyEndAllowThreads(__tstate);
25493 if (PyErr_Occurred()) SWIG_fail;
25494 }
25495 Py_INCREF(Py_None); resultobj = Py_None;
25496 return resultobj;
25497 fail:
25498 return NULL;
25499 }
25500
25501
25502 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25503 PyObject *resultobj;
25504 wxWindow *arg1 = (wxWindow *) 0 ;
25505 PyObject * obj0 = 0 ;
25506 char *kwnames[] = {
25507 (char *) "self", NULL
25508 };
25509
25510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25512 if (SWIG_arg_fail(1)) SWIG_fail;
25513 {
25514 PyThreadState* __tstate = wxPyBeginAllowThreads();
25515 (arg1)->Lower();
25516
25517 wxPyEndAllowThreads(__tstate);
25518 if (PyErr_Occurred()) SWIG_fail;
25519 }
25520 Py_INCREF(Py_None); resultobj = Py_None;
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25528 PyObject *resultobj;
25529 wxWindow *arg1 = (wxWindow *) 0 ;
25530 wxSize *arg2 = 0 ;
25531 wxSize temp2 ;
25532 PyObject * obj0 = 0 ;
25533 PyObject * obj1 = 0 ;
25534 char *kwnames[] = {
25535 (char *) "self",(char *) "size", NULL
25536 };
25537
25538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25540 if (SWIG_arg_fail(1)) SWIG_fail;
25541 {
25542 arg2 = &temp2;
25543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25544 }
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 (arg1)->SetClientSize((wxSize const &)*arg2);
25548
25549 wxPyEndAllowThreads(__tstate);
25550 if (PyErr_Occurred()) SWIG_fail;
25551 }
25552 Py_INCREF(Py_None); resultobj = Py_None;
25553 return resultobj;
25554 fail:
25555 return NULL;
25556 }
25557
25558
25559 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25560 PyObject *resultobj;
25561 wxWindow *arg1 = (wxWindow *) 0 ;
25562 int arg2 ;
25563 int arg3 ;
25564 PyObject * obj0 = 0 ;
25565 PyObject * obj1 = 0 ;
25566 PyObject * obj2 = 0 ;
25567 char *kwnames[] = {
25568 (char *) "self",(char *) "width",(char *) "height", NULL
25569 };
25570
25571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25573 if (SWIG_arg_fail(1)) SWIG_fail;
25574 {
25575 arg2 = (int)(SWIG_As_int(obj1));
25576 if (SWIG_arg_fail(2)) SWIG_fail;
25577 }
25578 {
25579 arg3 = (int)(SWIG_As_int(obj2));
25580 if (SWIG_arg_fail(3)) SWIG_fail;
25581 }
25582 {
25583 PyThreadState* __tstate = wxPyBeginAllowThreads();
25584 (arg1)->SetClientSize(arg2,arg3);
25585
25586 wxPyEndAllowThreads(__tstate);
25587 if (PyErr_Occurred()) SWIG_fail;
25588 }
25589 Py_INCREF(Py_None); resultobj = Py_None;
25590 return resultobj;
25591 fail:
25592 return NULL;
25593 }
25594
25595
25596 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25597 PyObject *resultobj;
25598 wxWindow *arg1 = (wxWindow *) 0 ;
25599 wxRect *arg2 = 0 ;
25600 wxRect temp2 ;
25601 PyObject * obj0 = 0 ;
25602 PyObject * obj1 = 0 ;
25603 char *kwnames[] = {
25604 (char *) "self",(char *) "rect", NULL
25605 };
25606
25607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25609 if (SWIG_arg_fail(1)) SWIG_fail;
25610 {
25611 arg2 = &temp2;
25612 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25613 }
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 (arg1)->SetClientSize((wxRect const &)*arg2);
25617
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 Py_INCREF(Py_None); resultobj = Py_None;
25622 return resultobj;
25623 fail:
25624 return NULL;
25625 }
25626
25627
25628 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25629 PyObject *resultobj;
25630 wxWindow *arg1 = (wxWindow *) 0 ;
25631 wxPoint result;
25632 PyObject * obj0 = 0 ;
25633 char *kwnames[] = {
25634 (char *) "self", NULL
25635 };
25636
25637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25639 if (SWIG_arg_fail(1)) SWIG_fail;
25640 {
25641 PyThreadState* __tstate = wxPyBeginAllowThreads();
25642 result = (arg1)->GetPosition();
25643
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 {
25648 wxPoint * resultptr;
25649 resultptr = new wxPoint((wxPoint &)(result));
25650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25651 }
25652 return resultobj;
25653 fail:
25654 return NULL;
25655 }
25656
25657
25658 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25659 PyObject *resultobj;
25660 wxWindow *arg1 = (wxWindow *) 0 ;
25661 int *arg2 = (int *) 0 ;
25662 int *arg3 = (int *) 0 ;
25663 int temp2 ;
25664 int res2 = 0 ;
25665 int temp3 ;
25666 int res3 = 0 ;
25667 PyObject * obj0 = 0 ;
25668 char *kwnames[] = {
25669 (char *) "self", NULL
25670 };
25671
25672 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25673 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25676 if (SWIG_arg_fail(1)) SWIG_fail;
25677 {
25678 PyThreadState* __tstate = wxPyBeginAllowThreads();
25679 (arg1)->GetPosition(arg2,arg3);
25680
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 Py_INCREF(Py_None); resultobj = Py_None;
25685 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25686 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25687 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25688 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25696 PyObject *resultobj;
25697 wxWindow *arg1 = (wxWindow *) 0 ;
25698 wxSize result;
25699 PyObject * obj0 = 0 ;
25700 char *kwnames[] = {
25701 (char *) "self", NULL
25702 };
25703
25704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25706 if (SWIG_arg_fail(1)) SWIG_fail;
25707 {
25708 PyThreadState* __tstate = wxPyBeginAllowThreads();
25709 result = ((wxWindow const *)arg1)->GetSize();
25710
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 {
25715 wxSize * resultptr;
25716 resultptr = new wxSize((wxSize &)(result));
25717 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25718 }
25719 return resultobj;
25720 fail:
25721 return NULL;
25722 }
25723
25724
25725 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25726 PyObject *resultobj;
25727 wxWindow *arg1 = (wxWindow *) 0 ;
25728 int *arg2 = (int *) 0 ;
25729 int *arg3 = (int *) 0 ;
25730 int temp2 ;
25731 int res2 = 0 ;
25732 int temp3 ;
25733 int res3 = 0 ;
25734 PyObject * obj0 = 0 ;
25735 char *kwnames[] = {
25736 (char *) "self", NULL
25737 };
25738
25739 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25740 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25743 if (SWIG_arg_fail(1)) SWIG_fail;
25744 {
25745 PyThreadState* __tstate = wxPyBeginAllowThreads();
25746 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25747
25748 wxPyEndAllowThreads(__tstate);
25749 if (PyErr_Occurred()) SWIG_fail;
25750 }
25751 Py_INCREF(Py_None); resultobj = Py_None;
25752 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25753 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25754 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25755 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25756 return resultobj;
25757 fail:
25758 return NULL;
25759 }
25760
25761
25762 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25763 PyObject *resultobj;
25764 wxWindow *arg1 = (wxWindow *) 0 ;
25765 wxRect result;
25766 PyObject * obj0 = 0 ;
25767 char *kwnames[] = {
25768 (char *) "self", NULL
25769 };
25770
25771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) 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 {
25775 PyThreadState* __tstate = wxPyBeginAllowThreads();
25776 result = ((wxWindow const *)arg1)->GetRect();
25777
25778 wxPyEndAllowThreads(__tstate);
25779 if (PyErr_Occurred()) SWIG_fail;
25780 }
25781 {
25782 wxRect * resultptr;
25783 resultptr = new wxRect((wxRect &)(result));
25784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25785 }
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj;
25794 wxWindow *arg1 = (wxWindow *) 0 ;
25795 wxSize result;
25796 PyObject * obj0 = 0 ;
25797 char *kwnames[] = {
25798 (char *) "self", NULL
25799 };
25800
25801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25803 if (SWIG_arg_fail(1)) SWIG_fail;
25804 {
25805 PyThreadState* __tstate = wxPyBeginAllowThreads();
25806 result = ((wxWindow const *)arg1)->GetClientSize();
25807
25808 wxPyEndAllowThreads(__tstate);
25809 if (PyErr_Occurred()) SWIG_fail;
25810 }
25811 {
25812 wxSize * resultptr;
25813 resultptr = new wxSize((wxSize &)(result));
25814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25815 }
25816 return resultobj;
25817 fail:
25818 return NULL;
25819 }
25820
25821
25822 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25823 PyObject *resultobj;
25824 wxWindow *arg1 = (wxWindow *) 0 ;
25825 int *arg2 = (int *) 0 ;
25826 int *arg3 = (int *) 0 ;
25827 int temp2 ;
25828 int res2 = 0 ;
25829 int temp3 ;
25830 int res3 = 0 ;
25831 PyObject * obj0 = 0 ;
25832 char *kwnames[] = {
25833 (char *) "self", NULL
25834 };
25835
25836 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25837 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(1)) SWIG_fail;
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25844
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 Py_INCREF(Py_None); resultobj = Py_None;
25849 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25850 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25851 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25852 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25860 PyObject *resultobj;
25861 wxWindow *arg1 = (wxWindow *) 0 ;
25862 wxPoint result;
25863 PyObject * obj0 = 0 ;
25864 char *kwnames[] = {
25865 (char *) "self", NULL
25866 };
25867
25868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25870 if (SWIG_arg_fail(1)) SWIG_fail;
25871 {
25872 PyThreadState* __tstate = wxPyBeginAllowThreads();
25873 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25874
25875 wxPyEndAllowThreads(__tstate);
25876 if (PyErr_Occurred()) SWIG_fail;
25877 }
25878 {
25879 wxPoint * resultptr;
25880 resultptr = new wxPoint((wxPoint &)(result));
25881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25882 }
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25890 PyObject *resultobj;
25891 wxWindow *arg1 = (wxWindow *) 0 ;
25892 wxRect result;
25893 PyObject * obj0 = 0 ;
25894 char *kwnames[] = {
25895 (char *) "self", NULL
25896 };
25897
25898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25900 if (SWIG_arg_fail(1)) SWIG_fail;
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 result = ((wxWindow const *)arg1)->GetClientRect();
25904
25905 wxPyEndAllowThreads(__tstate);
25906 if (PyErr_Occurred()) SWIG_fail;
25907 }
25908 {
25909 wxRect * resultptr;
25910 resultptr = new wxRect((wxRect &)(result));
25911 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25912 }
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25920 PyObject *resultobj;
25921 wxWindow *arg1 = (wxWindow *) 0 ;
25922 wxSize result;
25923 PyObject * obj0 = 0 ;
25924 char *kwnames[] = {
25925 (char *) "self", NULL
25926 };
25927
25928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25930 if (SWIG_arg_fail(1)) SWIG_fail;
25931 {
25932 PyThreadState* __tstate = wxPyBeginAllowThreads();
25933 result = ((wxWindow const *)arg1)->GetBestSize();
25934
25935 wxPyEndAllowThreads(__tstate);
25936 if (PyErr_Occurred()) SWIG_fail;
25937 }
25938 {
25939 wxSize * resultptr;
25940 resultptr = new wxSize((wxSize &)(result));
25941 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25942 }
25943 return resultobj;
25944 fail:
25945 return NULL;
25946 }
25947
25948
25949 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25950 PyObject *resultobj;
25951 wxWindow *arg1 = (wxWindow *) 0 ;
25952 int *arg2 = (int *) 0 ;
25953 int *arg3 = (int *) 0 ;
25954 int temp2 ;
25955 int res2 = 0 ;
25956 int temp3 ;
25957 int res3 = 0 ;
25958 PyObject * obj0 = 0 ;
25959 char *kwnames[] = {
25960 (char *) "self", NULL
25961 };
25962
25963 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25964 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
25970 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25971
25972 wxPyEndAllowThreads(__tstate);
25973 if (PyErr_Occurred()) SWIG_fail;
25974 }
25975 Py_INCREF(Py_None); resultobj = Py_None;
25976 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25977 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25978 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25979 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj;
25988 wxWindow *arg1 = (wxWindow *) 0 ;
25989 PyObject * obj0 = 0 ;
25990 char *kwnames[] = {
25991 (char *) "self", NULL
25992 };
25993
25994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25996 if (SWIG_arg_fail(1)) SWIG_fail;
25997 {
25998 PyThreadState* __tstate = wxPyBeginAllowThreads();
25999 (arg1)->InvalidateBestSize();
26000
26001 wxPyEndAllowThreads(__tstate);
26002 if (PyErr_Occurred()) SWIG_fail;
26003 }
26004 Py_INCREF(Py_None); resultobj = Py_None;
26005 return resultobj;
26006 fail:
26007 return NULL;
26008 }
26009
26010
26011 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26012 PyObject *resultobj;
26013 wxWindow *arg1 = (wxWindow *) 0 ;
26014 wxSize result;
26015 PyObject * obj0 = 0 ;
26016 char *kwnames[] = {
26017 (char *) "self", NULL
26018 };
26019
26020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26022 if (SWIG_arg_fail(1)) SWIG_fail;
26023 {
26024 PyThreadState* __tstate = wxPyBeginAllowThreads();
26025 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26026
26027 wxPyEndAllowThreads(__tstate);
26028 if (PyErr_Occurred()) SWIG_fail;
26029 }
26030 {
26031 wxSize * resultptr;
26032 resultptr = new wxSize((wxSize &)(result));
26033 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26034 }
26035 return resultobj;
26036 fail:
26037 return NULL;
26038 }
26039
26040
26041 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26042 PyObject *resultobj;
26043 wxWindow *arg1 = (wxWindow *) 0 ;
26044 wxSize result;
26045 PyObject * obj0 = 0 ;
26046 char *kwnames[] = {
26047 (char *) "self", NULL
26048 };
26049
26050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26052 if (SWIG_arg_fail(1)) SWIG_fail;
26053 {
26054 PyThreadState* __tstate = wxPyBeginAllowThreads();
26055 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26056
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 {
26061 wxSize * resultptr;
26062 resultptr = new wxSize((wxSize &)(result));
26063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26064 }
26065 return resultobj;
26066 fail:
26067 return NULL;
26068 }
26069
26070
26071 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26072 PyObject *resultobj;
26073 wxWindow *arg1 = (wxWindow *) 0 ;
26074 int arg2 = (int) wxBOTH ;
26075 PyObject * obj0 = 0 ;
26076 PyObject * obj1 = 0 ;
26077 char *kwnames[] = {
26078 (char *) "self",(char *) "direction", NULL
26079 };
26080
26081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26083 if (SWIG_arg_fail(1)) SWIG_fail;
26084 if (obj1) {
26085 {
26086 arg2 = (int)(SWIG_As_int(obj1));
26087 if (SWIG_arg_fail(2)) SWIG_fail;
26088 }
26089 }
26090 {
26091 PyThreadState* __tstate = wxPyBeginAllowThreads();
26092 (arg1)->Center(arg2);
26093
26094 wxPyEndAllowThreads(__tstate);
26095 if (PyErr_Occurred()) SWIG_fail;
26096 }
26097 Py_INCREF(Py_None); resultobj = Py_None;
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj;
26106 wxWindow *arg1 = (wxWindow *) 0 ;
26107 int arg2 = (int) wxBOTH ;
26108 PyObject * obj0 = 0 ;
26109 PyObject * obj1 = 0 ;
26110 char *kwnames[] = {
26111 (char *) "self",(char *) "dir", NULL
26112 };
26113
26114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26116 if (SWIG_arg_fail(1)) SWIG_fail;
26117 if (obj1) {
26118 {
26119 arg2 = (int)(SWIG_As_int(obj1));
26120 if (SWIG_arg_fail(2)) SWIG_fail;
26121 }
26122 }
26123 {
26124 PyThreadState* __tstate = wxPyBeginAllowThreads();
26125 (arg1)->CenterOnScreen(arg2);
26126
26127 wxPyEndAllowThreads(__tstate);
26128 if (PyErr_Occurred()) SWIG_fail;
26129 }
26130 Py_INCREF(Py_None); resultobj = Py_None;
26131 return resultobj;
26132 fail:
26133 return NULL;
26134 }
26135
26136
26137 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26138 PyObject *resultobj;
26139 wxWindow *arg1 = (wxWindow *) 0 ;
26140 int arg2 = (int) wxBOTH ;
26141 PyObject * obj0 = 0 ;
26142 PyObject * obj1 = 0 ;
26143 char *kwnames[] = {
26144 (char *) "self",(char *) "dir", NULL
26145 };
26146
26147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26149 if (SWIG_arg_fail(1)) SWIG_fail;
26150 if (obj1) {
26151 {
26152 arg2 = (int)(SWIG_As_int(obj1));
26153 if (SWIG_arg_fail(2)) SWIG_fail;
26154 }
26155 }
26156 {
26157 PyThreadState* __tstate = wxPyBeginAllowThreads();
26158 (arg1)->CenterOnParent(arg2);
26159
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 Py_INCREF(Py_None); resultobj = Py_None;
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26171 PyObject *resultobj;
26172 wxWindow *arg1 = (wxWindow *) 0 ;
26173 PyObject * obj0 = 0 ;
26174 char *kwnames[] = {
26175 (char *) "self", NULL
26176 };
26177
26178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26180 if (SWIG_arg_fail(1)) SWIG_fail;
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 (arg1)->Fit();
26184
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 Py_INCREF(Py_None); resultobj = Py_None;
26189 return resultobj;
26190 fail:
26191 return NULL;
26192 }
26193
26194
26195 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26196 PyObject *resultobj;
26197 wxWindow *arg1 = (wxWindow *) 0 ;
26198 PyObject * obj0 = 0 ;
26199 char *kwnames[] = {
26200 (char *) "self", NULL
26201 };
26202
26203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26205 if (SWIG_arg_fail(1)) SWIG_fail;
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 (arg1)->FitInside();
26209
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 Py_INCREF(Py_None); resultobj = Py_None;
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26221 PyObject *resultobj;
26222 wxWindow *arg1 = (wxWindow *) 0 ;
26223 int arg2 ;
26224 int arg3 ;
26225 int arg4 = (int) -1 ;
26226 int arg5 = (int) -1 ;
26227 int arg6 = (int) -1 ;
26228 int arg7 = (int) -1 ;
26229 PyObject * obj0 = 0 ;
26230 PyObject * obj1 = 0 ;
26231 PyObject * obj2 = 0 ;
26232 PyObject * obj3 = 0 ;
26233 PyObject * obj4 = 0 ;
26234 PyObject * obj5 = 0 ;
26235 PyObject * obj6 = 0 ;
26236 char *kwnames[] = {
26237 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26238 };
26239
26240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26242 if (SWIG_arg_fail(1)) SWIG_fail;
26243 {
26244 arg2 = (int)(SWIG_As_int(obj1));
26245 if (SWIG_arg_fail(2)) SWIG_fail;
26246 }
26247 {
26248 arg3 = (int)(SWIG_As_int(obj2));
26249 if (SWIG_arg_fail(3)) SWIG_fail;
26250 }
26251 if (obj3) {
26252 {
26253 arg4 = (int)(SWIG_As_int(obj3));
26254 if (SWIG_arg_fail(4)) SWIG_fail;
26255 }
26256 }
26257 if (obj4) {
26258 {
26259 arg5 = (int)(SWIG_As_int(obj4));
26260 if (SWIG_arg_fail(5)) SWIG_fail;
26261 }
26262 }
26263 if (obj5) {
26264 {
26265 arg6 = (int)(SWIG_As_int(obj5));
26266 if (SWIG_arg_fail(6)) SWIG_fail;
26267 }
26268 }
26269 if (obj6) {
26270 {
26271 arg7 = (int)(SWIG_As_int(obj6));
26272 if (SWIG_arg_fail(7)) SWIG_fail;
26273 }
26274 }
26275 {
26276 PyThreadState* __tstate = wxPyBeginAllowThreads();
26277 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26278
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 Py_INCREF(Py_None); resultobj = Py_None;
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26290 PyObject *resultobj;
26291 wxWindow *arg1 = (wxWindow *) 0 ;
26292 wxSize *arg2 = 0 ;
26293 wxSize const &arg3_defvalue = wxDefaultSize ;
26294 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26295 wxSize const &arg4_defvalue = wxDefaultSize ;
26296 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26297 wxSize temp2 ;
26298 wxSize temp3 ;
26299 wxSize temp4 ;
26300 PyObject * obj0 = 0 ;
26301 PyObject * obj1 = 0 ;
26302 PyObject * obj2 = 0 ;
26303 PyObject * obj3 = 0 ;
26304 char *kwnames[] = {
26305 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26306 };
26307
26308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26310 if (SWIG_arg_fail(1)) SWIG_fail;
26311 {
26312 arg2 = &temp2;
26313 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26314 }
26315 if (obj2) {
26316 {
26317 arg3 = &temp3;
26318 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26319 }
26320 }
26321 if (obj3) {
26322 {
26323 arg4 = &temp4;
26324 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26325 }
26326 }
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 Py_INCREF(Py_None); resultobj = Py_None;
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj;
26343 wxWindow *arg1 = (wxWindow *) 0 ;
26344 int arg2 ;
26345 int arg3 ;
26346 int arg4 = (int) -1 ;
26347 int arg5 = (int) -1 ;
26348 PyObject * obj0 = 0 ;
26349 PyObject * obj1 = 0 ;
26350 PyObject * obj2 = 0 ;
26351 PyObject * obj3 = 0 ;
26352 PyObject * obj4 = 0 ;
26353 char *kwnames[] = {
26354 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26355 };
26356
26357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26359 if (SWIG_arg_fail(1)) SWIG_fail;
26360 {
26361 arg2 = (int)(SWIG_As_int(obj1));
26362 if (SWIG_arg_fail(2)) SWIG_fail;
26363 }
26364 {
26365 arg3 = (int)(SWIG_As_int(obj2));
26366 if (SWIG_arg_fail(3)) SWIG_fail;
26367 }
26368 if (obj3) {
26369 {
26370 arg4 = (int)(SWIG_As_int(obj3));
26371 if (SWIG_arg_fail(4)) SWIG_fail;
26372 }
26373 }
26374 if (obj4) {
26375 {
26376 arg5 = (int)(SWIG_As_int(obj4));
26377 if (SWIG_arg_fail(5)) SWIG_fail;
26378 }
26379 }
26380 {
26381 PyThreadState* __tstate = wxPyBeginAllowThreads();
26382 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26383
26384 wxPyEndAllowThreads(__tstate);
26385 if (PyErr_Occurred()) SWIG_fail;
26386 }
26387 Py_INCREF(Py_None); resultobj = Py_None;
26388 return resultobj;
26389 fail:
26390 return NULL;
26391 }
26392
26393
26394 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26395 PyObject *resultobj;
26396 wxWindow *arg1 = (wxWindow *) 0 ;
26397 wxSize *arg2 = 0 ;
26398 wxSize const &arg3_defvalue = wxDefaultSize ;
26399 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26400 wxSize temp2 ;
26401 wxSize temp3 ;
26402 PyObject * obj0 = 0 ;
26403 PyObject * obj1 = 0 ;
26404 PyObject * obj2 = 0 ;
26405 char *kwnames[] = {
26406 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26407 };
26408
26409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26411 if (SWIG_arg_fail(1)) SWIG_fail;
26412 {
26413 arg2 = &temp2;
26414 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26415 }
26416 if (obj2) {
26417 {
26418 arg3 = &temp3;
26419 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26420 }
26421 }
26422 {
26423 PyThreadState* __tstate = wxPyBeginAllowThreads();
26424 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26425
26426 wxPyEndAllowThreads(__tstate);
26427 if (PyErr_Occurred()) SWIG_fail;
26428 }
26429 Py_INCREF(Py_None); resultobj = Py_None;
26430 return resultobj;
26431 fail:
26432 return NULL;
26433 }
26434
26435
26436 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26437 PyObject *resultobj;
26438 wxWindow *arg1 = (wxWindow *) 0 ;
26439 wxSize result;
26440 PyObject * obj0 = 0 ;
26441 char *kwnames[] = {
26442 (char *) "self", NULL
26443 };
26444
26445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26447 if (SWIG_arg_fail(1)) SWIG_fail;
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 result = ((wxWindow const *)arg1)->GetMaxSize();
26451
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 {
26456 wxSize * resultptr;
26457 resultptr = new wxSize((wxSize &)(result));
26458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26459 }
26460 return resultobj;
26461 fail:
26462 return NULL;
26463 }
26464
26465
26466 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26467 PyObject *resultobj;
26468 wxWindow *arg1 = (wxWindow *) 0 ;
26469 wxSize result;
26470 PyObject * obj0 = 0 ;
26471 char *kwnames[] = {
26472 (char *) "self", NULL
26473 };
26474
26475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26477 if (SWIG_arg_fail(1)) SWIG_fail;
26478 {
26479 PyThreadState* __tstate = wxPyBeginAllowThreads();
26480 result = ((wxWindow const *)arg1)->GetMinSize();
26481
26482 wxPyEndAllowThreads(__tstate);
26483 if (PyErr_Occurred()) SWIG_fail;
26484 }
26485 {
26486 wxSize * resultptr;
26487 resultptr = new wxSize((wxSize &)(result));
26488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26489 }
26490 return resultobj;
26491 fail:
26492 return NULL;
26493 }
26494
26495
26496 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26497 PyObject *resultobj;
26498 wxWindow *arg1 = (wxWindow *) 0 ;
26499 wxSize *arg2 = 0 ;
26500 wxSize temp2 ;
26501 PyObject * obj0 = 0 ;
26502 PyObject * obj1 = 0 ;
26503 char *kwnames[] = {
26504 (char *) "self",(char *) "minSize", NULL
26505 };
26506
26507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26509 if (SWIG_arg_fail(1)) SWIG_fail;
26510 {
26511 arg2 = &temp2;
26512 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26513 }
26514 {
26515 PyThreadState* __tstate = wxPyBeginAllowThreads();
26516 (arg1)->SetMinSize((wxSize const &)*arg2);
26517
26518 wxPyEndAllowThreads(__tstate);
26519 if (PyErr_Occurred()) SWIG_fail;
26520 }
26521 Py_INCREF(Py_None); resultobj = Py_None;
26522 return resultobj;
26523 fail:
26524 return NULL;
26525 }
26526
26527
26528 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26529 PyObject *resultobj;
26530 wxWindow *arg1 = (wxWindow *) 0 ;
26531 wxSize *arg2 = 0 ;
26532 wxSize temp2 ;
26533 PyObject * obj0 = 0 ;
26534 PyObject * obj1 = 0 ;
26535 char *kwnames[] = {
26536 (char *) "self",(char *) "maxSize", NULL
26537 };
26538
26539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26541 if (SWIG_arg_fail(1)) SWIG_fail;
26542 {
26543 arg2 = &temp2;
26544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26545 }
26546 {
26547 PyThreadState* __tstate = wxPyBeginAllowThreads();
26548 (arg1)->SetMaxSize((wxSize const &)*arg2);
26549
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 Py_INCREF(Py_None); resultobj = Py_None;
26554 return resultobj;
26555 fail:
26556 return NULL;
26557 }
26558
26559
26560 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj;
26562 wxWindow *arg1 = (wxWindow *) 0 ;
26563 int result;
26564 PyObject * obj0 = 0 ;
26565 char *kwnames[] = {
26566 (char *) "self", NULL
26567 };
26568
26569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26571 if (SWIG_arg_fail(1)) SWIG_fail;
26572 {
26573 PyThreadState* __tstate = wxPyBeginAllowThreads();
26574 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26575
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 {
26580 resultobj = SWIG_From_int((int)(result));
26581 }
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj;
26590 wxWindow *arg1 = (wxWindow *) 0 ;
26591 int result;
26592 PyObject * obj0 = 0 ;
26593 char *kwnames[] = {
26594 (char *) "self", NULL
26595 };
26596
26597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26599 if (SWIG_arg_fail(1)) SWIG_fail;
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26603
26604 wxPyEndAllowThreads(__tstate);
26605 if (PyErr_Occurred()) SWIG_fail;
26606 }
26607 {
26608 resultobj = SWIG_From_int((int)(result));
26609 }
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26617 PyObject *resultobj;
26618 wxWindow *arg1 = (wxWindow *) 0 ;
26619 int result;
26620 PyObject * obj0 = 0 ;
26621 char *kwnames[] = {
26622 (char *) "self", NULL
26623 };
26624
26625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26627 if (SWIG_arg_fail(1)) SWIG_fail;
26628 {
26629 PyThreadState* __tstate = wxPyBeginAllowThreads();
26630 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26631
26632 wxPyEndAllowThreads(__tstate);
26633 if (PyErr_Occurred()) SWIG_fail;
26634 }
26635 {
26636 resultobj = SWIG_From_int((int)(result));
26637 }
26638 return resultobj;
26639 fail:
26640 return NULL;
26641 }
26642
26643
26644 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26645 PyObject *resultobj;
26646 wxWindow *arg1 = (wxWindow *) 0 ;
26647 int result;
26648 PyObject * obj0 = 0 ;
26649 char *kwnames[] = {
26650 (char *) "self", NULL
26651 };
26652
26653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26655 if (SWIG_arg_fail(1)) SWIG_fail;
26656 {
26657 PyThreadState* __tstate = wxPyBeginAllowThreads();
26658 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26659
26660 wxPyEndAllowThreads(__tstate);
26661 if (PyErr_Occurred()) SWIG_fail;
26662 }
26663 {
26664 resultobj = SWIG_From_int((int)(result));
26665 }
26666 return resultobj;
26667 fail:
26668 return NULL;
26669 }
26670
26671
26672 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26673 PyObject *resultobj;
26674 wxWindow *arg1 = (wxWindow *) 0 ;
26675 wxSize *arg2 = 0 ;
26676 wxSize temp2 ;
26677 PyObject * obj0 = 0 ;
26678 PyObject * obj1 = 0 ;
26679 char *kwnames[] = {
26680 (char *) "self",(char *) "size", NULL
26681 };
26682
26683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26685 if (SWIG_arg_fail(1)) SWIG_fail;
26686 {
26687 arg2 = &temp2;
26688 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26689 }
26690 {
26691 PyThreadState* __tstate = wxPyBeginAllowThreads();
26692 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26693
26694 wxPyEndAllowThreads(__tstate);
26695 if (PyErr_Occurred()) SWIG_fail;
26696 }
26697 Py_INCREF(Py_None); resultobj = Py_None;
26698 return resultobj;
26699 fail:
26700 return NULL;
26701 }
26702
26703
26704 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26705 PyObject *resultobj;
26706 wxWindow *arg1 = (wxWindow *) 0 ;
26707 int arg2 ;
26708 int arg3 ;
26709 PyObject * obj0 = 0 ;
26710 PyObject * obj1 = 0 ;
26711 PyObject * obj2 = 0 ;
26712 char *kwnames[] = {
26713 (char *) "self",(char *) "w",(char *) "h", NULL
26714 };
26715
26716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26718 if (SWIG_arg_fail(1)) SWIG_fail;
26719 {
26720 arg2 = (int)(SWIG_As_int(obj1));
26721 if (SWIG_arg_fail(2)) SWIG_fail;
26722 }
26723 {
26724 arg3 = (int)(SWIG_As_int(obj2));
26725 if (SWIG_arg_fail(3)) SWIG_fail;
26726 }
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 (arg1)->SetVirtualSize(arg2,arg3);
26730
26731 wxPyEndAllowThreads(__tstate);
26732 if (PyErr_Occurred()) SWIG_fail;
26733 }
26734 Py_INCREF(Py_None); resultobj = Py_None;
26735 return resultobj;
26736 fail:
26737 return NULL;
26738 }
26739
26740
26741 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26742 PyObject *resultobj;
26743 wxWindow *arg1 = (wxWindow *) 0 ;
26744 wxSize result;
26745 PyObject * obj0 = 0 ;
26746 char *kwnames[] = {
26747 (char *) "self", NULL
26748 };
26749
26750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26752 if (SWIG_arg_fail(1)) SWIG_fail;
26753 {
26754 PyThreadState* __tstate = wxPyBeginAllowThreads();
26755 result = ((wxWindow const *)arg1)->GetVirtualSize();
26756
26757 wxPyEndAllowThreads(__tstate);
26758 if (PyErr_Occurred()) SWIG_fail;
26759 }
26760 {
26761 wxSize * resultptr;
26762 resultptr = new wxSize((wxSize &)(result));
26763 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26764 }
26765 return resultobj;
26766 fail:
26767 return NULL;
26768 }
26769
26770
26771 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26772 PyObject *resultobj;
26773 wxWindow *arg1 = (wxWindow *) 0 ;
26774 int *arg2 = (int *) 0 ;
26775 int *arg3 = (int *) 0 ;
26776 int temp2 ;
26777 int res2 = 0 ;
26778 int temp3 ;
26779 int res3 = 0 ;
26780 PyObject * obj0 = 0 ;
26781 char *kwnames[] = {
26782 (char *) "self", NULL
26783 };
26784
26785 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26786 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26789 if (SWIG_arg_fail(1)) SWIG_fail;
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 Py_INCREF(Py_None); resultobj = Py_None;
26798 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26799 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26800 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26801 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj;
26810 wxWindow *arg1 = (wxWindow *) 0 ;
26811 wxSize result;
26812 PyObject * obj0 = 0 ;
26813 char *kwnames[] = {
26814 (char *) "self", NULL
26815 };
26816
26817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26819 if (SWIG_arg_fail(1)) SWIG_fail;
26820 {
26821 PyThreadState* __tstate = wxPyBeginAllowThreads();
26822 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26823
26824 wxPyEndAllowThreads(__tstate);
26825 if (PyErr_Occurred()) SWIG_fail;
26826 }
26827 {
26828 wxSize * resultptr;
26829 resultptr = new wxSize((wxSize &)(result));
26830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26831 }
26832 return resultobj;
26833 fail:
26834 return NULL;
26835 }
26836
26837
26838 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26839 PyObject *resultobj;
26840 wxWindow *arg1 = (wxWindow *) 0 ;
26841 bool arg2 = (bool) true ;
26842 bool result;
26843 PyObject * obj0 = 0 ;
26844 PyObject * obj1 = 0 ;
26845 char *kwnames[] = {
26846 (char *) "self",(char *) "show", NULL
26847 };
26848
26849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26851 if (SWIG_arg_fail(1)) SWIG_fail;
26852 if (obj1) {
26853 {
26854 arg2 = (bool)(SWIG_As_bool(obj1));
26855 if (SWIG_arg_fail(2)) SWIG_fail;
26856 }
26857 }
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 result = (bool)(arg1)->Show(arg2);
26861
26862 wxPyEndAllowThreads(__tstate);
26863 if (PyErr_Occurred()) SWIG_fail;
26864 }
26865 {
26866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26867 }
26868 return resultobj;
26869 fail:
26870 return NULL;
26871 }
26872
26873
26874 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26875 PyObject *resultobj;
26876 wxWindow *arg1 = (wxWindow *) 0 ;
26877 bool result;
26878 PyObject * obj0 = 0 ;
26879 char *kwnames[] = {
26880 (char *) "self", NULL
26881 };
26882
26883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26885 if (SWIG_arg_fail(1)) SWIG_fail;
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 result = (bool)(arg1)->Hide();
26889
26890 wxPyEndAllowThreads(__tstate);
26891 if (PyErr_Occurred()) SWIG_fail;
26892 }
26893 {
26894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26895 }
26896 return resultobj;
26897 fail:
26898 return NULL;
26899 }
26900
26901
26902 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj;
26904 wxWindow *arg1 = (wxWindow *) 0 ;
26905 bool arg2 = (bool) true ;
26906 bool result;
26907 PyObject * obj0 = 0 ;
26908 PyObject * obj1 = 0 ;
26909 char *kwnames[] = {
26910 (char *) "self",(char *) "enable", NULL
26911 };
26912
26913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26915 if (SWIG_arg_fail(1)) SWIG_fail;
26916 if (obj1) {
26917 {
26918 arg2 = (bool)(SWIG_As_bool(obj1));
26919 if (SWIG_arg_fail(2)) SWIG_fail;
26920 }
26921 }
26922 {
26923 PyThreadState* __tstate = wxPyBeginAllowThreads();
26924 result = (bool)(arg1)->Enable(arg2);
26925
26926 wxPyEndAllowThreads(__tstate);
26927 if (PyErr_Occurred()) SWIG_fail;
26928 }
26929 {
26930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26931 }
26932 return resultobj;
26933 fail:
26934 return NULL;
26935 }
26936
26937
26938 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26939 PyObject *resultobj;
26940 wxWindow *arg1 = (wxWindow *) 0 ;
26941 bool result;
26942 PyObject * obj0 = 0 ;
26943 char *kwnames[] = {
26944 (char *) "self", NULL
26945 };
26946
26947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26949 if (SWIG_arg_fail(1)) SWIG_fail;
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 result = (bool)(arg1)->Disable();
26953
26954 wxPyEndAllowThreads(__tstate);
26955 if (PyErr_Occurred()) SWIG_fail;
26956 }
26957 {
26958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26959 }
26960 return resultobj;
26961 fail:
26962 return NULL;
26963 }
26964
26965
26966 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26967 PyObject *resultobj;
26968 wxWindow *arg1 = (wxWindow *) 0 ;
26969 bool result;
26970 PyObject * obj0 = 0 ;
26971 char *kwnames[] = {
26972 (char *) "self", NULL
26973 };
26974
26975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26977 if (SWIG_arg_fail(1)) SWIG_fail;
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 result = (bool)((wxWindow const *)arg1)->IsShown();
26981
26982 wxPyEndAllowThreads(__tstate);
26983 if (PyErr_Occurred()) SWIG_fail;
26984 }
26985 {
26986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26987 }
26988 return resultobj;
26989 fail:
26990 return NULL;
26991 }
26992
26993
26994 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26995 PyObject *resultobj;
26996 wxWindow *arg1 = (wxWindow *) 0 ;
26997 bool result;
26998 PyObject * obj0 = 0 ;
26999 char *kwnames[] = {
27000 (char *) "self", NULL
27001 };
27002
27003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27005 if (SWIG_arg_fail(1)) SWIG_fail;
27006 {
27007 PyThreadState* __tstate = wxPyBeginAllowThreads();
27008 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27009
27010 wxPyEndAllowThreads(__tstate);
27011 if (PyErr_Occurred()) SWIG_fail;
27012 }
27013 {
27014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27015 }
27016 return resultobj;
27017 fail:
27018 return NULL;
27019 }
27020
27021
27022 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27023 PyObject *resultobj;
27024 wxWindow *arg1 = (wxWindow *) 0 ;
27025 long arg2 ;
27026 PyObject * obj0 = 0 ;
27027 PyObject * obj1 = 0 ;
27028 char *kwnames[] = {
27029 (char *) "self",(char *) "style", NULL
27030 };
27031
27032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27034 if (SWIG_arg_fail(1)) SWIG_fail;
27035 {
27036 arg2 = (long)(SWIG_As_long(obj1));
27037 if (SWIG_arg_fail(2)) SWIG_fail;
27038 }
27039 {
27040 PyThreadState* __tstate = wxPyBeginAllowThreads();
27041 (arg1)->SetWindowStyleFlag(arg2);
27042
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 Py_INCREF(Py_None); resultobj = Py_None;
27047 return resultobj;
27048 fail:
27049 return NULL;
27050 }
27051
27052
27053 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27054 PyObject *resultobj;
27055 wxWindow *arg1 = (wxWindow *) 0 ;
27056 long result;
27057 PyObject * obj0 = 0 ;
27058 char *kwnames[] = {
27059 (char *) "self", NULL
27060 };
27061
27062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27064 if (SWIG_arg_fail(1)) SWIG_fail;
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27068
27069 wxPyEndAllowThreads(__tstate);
27070 if (PyErr_Occurred()) SWIG_fail;
27071 }
27072 {
27073 resultobj = SWIG_From_long((long)(result));
27074 }
27075 return resultobj;
27076 fail:
27077 return NULL;
27078 }
27079
27080
27081 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27082 PyObject *resultobj;
27083 wxWindow *arg1 = (wxWindow *) 0 ;
27084 int arg2 ;
27085 bool result;
27086 PyObject * obj0 = 0 ;
27087 PyObject * obj1 = 0 ;
27088 char *kwnames[] = {
27089 (char *) "self",(char *) "flag", NULL
27090 };
27091
27092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27094 if (SWIG_arg_fail(1)) SWIG_fail;
27095 {
27096 arg2 = (int)(SWIG_As_int(obj1));
27097 if (SWIG_arg_fail(2)) SWIG_fail;
27098 }
27099 {
27100 PyThreadState* __tstate = wxPyBeginAllowThreads();
27101 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27102
27103 wxPyEndAllowThreads(__tstate);
27104 if (PyErr_Occurred()) SWIG_fail;
27105 }
27106 {
27107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27108 }
27109 return resultobj;
27110 fail:
27111 return NULL;
27112 }
27113
27114
27115 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27116 PyObject *resultobj;
27117 wxWindow *arg1 = (wxWindow *) 0 ;
27118 bool result;
27119 PyObject * obj0 = 0 ;
27120 char *kwnames[] = {
27121 (char *) "self", NULL
27122 };
27123
27124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27126 if (SWIG_arg_fail(1)) SWIG_fail;
27127 {
27128 PyThreadState* __tstate = wxPyBeginAllowThreads();
27129 result = (bool)((wxWindow const *)arg1)->IsRetained();
27130
27131 wxPyEndAllowThreads(__tstate);
27132 if (PyErr_Occurred()) SWIG_fail;
27133 }
27134 {
27135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27136 }
27137 return resultobj;
27138 fail:
27139 return NULL;
27140 }
27141
27142
27143 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27144 PyObject *resultobj;
27145 wxWindow *arg1 = (wxWindow *) 0 ;
27146 long arg2 ;
27147 PyObject * obj0 = 0 ;
27148 PyObject * obj1 = 0 ;
27149 char *kwnames[] = {
27150 (char *) "self",(char *) "exStyle", NULL
27151 };
27152
27153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27155 if (SWIG_arg_fail(1)) SWIG_fail;
27156 {
27157 arg2 = (long)(SWIG_As_long(obj1));
27158 if (SWIG_arg_fail(2)) SWIG_fail;
27159 }
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 (arg1)->SetExtraStyle(arg2);
27163
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 Py_INCREF(Py_None); resultobj = Py_None;
27168 return resultobj;
27169 fail:
27170 return NULL;
27171 }
27172
27173
27174 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27175 PyObject *resultobj;
27176 wxWindow *arg1 = (wxWindow *) 0 ;
27177 long result;
27178 PyObject * obj0 = 0 ;
27179 char *kwnames[] = {
27180 (char *) "self", NULL
27181 };
27182
27183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27185 if (SWIG_arg_fail(1)) SWIG_fail;
27186 {
27187 PyThreadState* __tstate = wxPyBeginAllowThreads();
27188 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27189
27190 wxPyEndAllowThreads(__tstate);
27191 if (PyErr_Occurred()) SWIG_fail;
27192 }
27193 {
27194 resultobj = SWIG_From_long((long)(result));
27195 }
27196 return resultobj;
27197 fail:
27198 return NULL;
27199 }
27200
27201
27202 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27203 PyObject *resultobj;
27204 wxWindow *arg1 = (wxWindow *) 0 ;
27205 bool arg2 = (bool) true ;
27206 PyObject * obj0 = 0 ;
27207 PyObject * obj1 = 0 ;
27208 char *kwnames[] = {
27209 (char *) "self",(char *) "modal", NULL
27210 };
27211
27212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27214 if (SWIG_arg_fail(1)) SWIG_fail;
27215 if (obj1) {
27216 {
27217 arg2 = (bool)(SWIG_As_bool(obj1));
27218 if (SWIG_arg_fail(2)) SWIG_fail;
27219 }
27220 }
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 (arg1)->MakeModal(arg2);
27224
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 Py_INCREF(Py_None); resultobj = Py_None;
27229 return resultobj;
27230 fail:
27231 return NULL;
27232 }
27233
27234
27235 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27236 PyObject *resultobj;
27237 wxWindow *arg1 = (wxWindow *) 0 ;
27238 bool arg2 ;
27239 PyObject * obj0 = 0 ;
27240 PyObject * obj1 = 0 ;
27241 char *kwnames[] = {
27242 (char *) "self",(char *) "enableTheme", NULL
27243 };
27244
27245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27247 if (SWIG_arg_fail(1)) SWIG_fail;
27248 {
27249 arg2 = (bool)(SWIG_As_bool(obj1));
27250 if (SWIG_arg_fail(2)) SWIG_fail;
27251 }
27252 {
27253 PyThreadState* __tstate = wxPyBeginAllowThreads();
27254 (arg1)->SetThemeEnabled(arg2);
27255
27256 wxPyEndAllowThreads(__tstate);
27257 if (PyErr_Occurred()) SWIG_fail;
27258 }
27259 Py_INCREF(Py_None); resultobj = Py_None;
27260 return resultobj;
27261 fail:
27262 return NULL;
27263 }
27264
27265
27266 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27267 PyObject *resultobj;
27268 wxWindow *arg1 = (wxWindow *) 0 ;
27269 bool result;
27270 PyObject * obj0 = 0 ;
27271 char *kwnames[] = {
27272 (char *) "self", NULL
27273 };
27274
27275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27277 if (SWIG_arg_fail(1)) SWIG_fail;
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27281
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 {
27286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27287 }
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj;
27296 wxWindow *arg1 = (wxWindow *) 0 ;
27297 PyObject * obj0 = 0 ;
27298 char *kwnames[] = {
27299 (char *) "self", NULL
27300 };
27301
27302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27304 if (SWIG_arg_fail(1)) SWIG_fail;
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 (arg1)->SetFocus();
27308
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 Py_INCREF(Py_None); resultobj = Py_None;
27313 return resultobj;
27314 fail:
27315 return NULL;
27316 }
27317
27318
27319 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27320 PyObject *resultobj;
27321 wxWindow *arg1 = (wxWindow *) 0 ;
27322 PyObject * obj0 = 0 ;
27323 char *kwnames[] = {
27324 (char *) "self", NULL
27325 };
27326
27327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27329 if (SWIG_arg_fail(1)) SWIG_fail;
27330 {
27331 PyThreadState* __tstate = wxPyBeginAllowThreads();
27332 (arg1)->SetFocusFromKbd();
27333
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 Py_INCREF(Py_None); resultobj = Py_None;
27338 return resultobj;
27339 fail:
27340 return NULL;
27341 }
27342
27343
27344 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27345 PyObject *resultobj;
27346 wxWindow *result;
27347 char *kwnames[] = {
27348 NULL
27349 };
27350
27351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27352 {
27353 if (!wxPyCheckForApp()) SWIG_fail;
27354 PyThreadState* __tstate = wxPyBeginAllowThreads();
27355 result = (wxWindow *)wxWindow::FindFocus();
27356
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 {
27361 resultobj = wxPyMake_wxObject(result, 0);
27362 }
27363 return resultobj;
27364 fail:
27365 return NULL;
27366 }
27367
27368
27369 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27370 PyObject *resultobj;
27371 wxWindow *arg1 = (wxWindow *) 0 ;
27372 bool result;
27373 PyObject * obj0 = 0 ;
27374 char *kwnames[] = {
27375 (char *) "self", NULL
27376 };
27377
27378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27380 if (SWIG_arg_fail(1)) SWIG_fail;
27381 {
27382 PyThreadState* __tstate = wxPyBeginAllowThreads();
27383 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27384
27385 wxPyEndAllowThreads(__tstate);
27386 if (PyErr_Occurred()) SWIG_fail;
27387 }
27388 {
27389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27390 }
27391 return resultobj;
27392 fail:
27393 return NULL;
27394 }
27395
27396
27397 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27398 PyObject *resultobj;
27399 wxWindow *arg1 = (wxWindow *) 0 ;
27400 bool result;
27401 PyObject * obj0 = 0 ;
27402 char *kwnames[] = {
27403 (char *) "self", NULL
27404 };
27405
27406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27408 if (SWIG_arg_fail(1)) SWIG_fail;
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27412
27413 wxPyEndAllowThreads(__tstate);
27414 if (PyErr_Occurred()) SWIG_fail;
27415 }
27416 {
27417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27418 }
27419 return resultobj;
27420 fail:
27421 return NULL;
27422 }
27423
27424
27425 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27426 PyObject *resultobj;
27427 wxWindow *arg1 = (wxWindow *) 0 ;
27428 wxWindow *result;
27429 PyObject * obj0 = 0 ;
27430 char *kwnames[] = {
27431 (char *) "self", NULL
27432 };
27433
27434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27436 if (SWIG_arg_fail(1)) SWIG_fail;
27437 {
27438 PyThreadState* __tstate = wxPyBeginAllowThreads();
27439 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27440
27441 wxPyEndAllowThreads(__tstate);
27442 if (PyErr_Occurred()) SWIG_fail;
27443 }
27444 {
27445 resultobj = wxPyMake_wxObject(result, 0);
27446 }
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27454 PyObject *resultobj;
27455 wxWindow *arg1 = (wxWindow *) 0 ;
27456 wxWindow *arg2 = (wxWindow *) 0 ;
27457 wxWindow *result;
27458 PyObject * obj0 = 0 ;
27459 PyObject * obj1 = 0 ;
27460 char *kwnames[] = {
27461 (char *) "self",(char *) "child", NULL
27462 };
27463
27464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27466 if (SWIG_arg_fail(1)) SWIG_fail;
27467 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27468 if (SWIG_arg_fail(2)) SWIG_fail;
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27472
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 {
27477 resultobj = wxPyMake_wxObject(result, 0);
27478 }
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj;
27487 wxWindow *arg1 = (wxWindow *) 0 ;
27488 wxWindow *arg2 = (wxWindow *) 0 ;
27489 PyObject * obj0 = 0 ;
27490 PyObject * obj1 = 0 ;
27491 char *kwnames[] = {
27492 (char *) "self",(char *) "win", NULL
27493 };
27494
27495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27497 if (SWIG_arg_fail(1)) SWIG_fail;
27498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27499 if (SWIG_arg_fail(2)) SWIG_fail;
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 (arg1)->SetTmpDefaultItem(arg2);
27503
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 Py_INCREF(Py_None); resultobj = Py_None;
27508 return resultobj;
27509 fail:
27510 return NULL;
27511 }
27512
27513
27514 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27515 PyObject *resultobj;
27516 wxWindow *arg1 = (wxWindow *) 0 ;
27517 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27518 bool result;
27519 PyObject * obj0 = 0 ;
27520 PyObject * obj1 = 0 ;
27521 char *kwnames[] = {
27522 (char *) "self",(char *) "flags", NULL
27523 };
27524
27525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27527 if (SWIG_arg_fail(1)) SWIG_fail;
27528 if (obj1) {
27529 {
27530 arg2 = (int)(SWIG_As_int(obj1));
27531 if (SWIG_arg_fail(2)) SWIG_fail;
27532 }
27533 }
27534 {
27535 PyThreadState* __tstate = wxPyBeginAllowThreads();
27536 result = (bool)(arg1)->Navigate(arg2);
27537
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 {
27542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27543 }
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27551 PyObject *resultobj;
27552 wxWindow *arg1 = (wxWindow *) 0 ;
27553 wxWindow *arg2 = (wxWindow *) 0 ;
27554 PyObject * obj0 = 0 ;
27555 PyObject * obj1 = 0 ;
27556 char *kwnames[] = {
27557 (char *) "self",(char *) "win", NULL
27558 };
27559
27560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27562 if (SWIG_arg_fail(1)) SWIG_fail;
27563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27564 if (SWIG_arg_fail(2)) SWIG_fail;
27565 {
27566 PyThreadState* __tstate = wxPyBeginAllowThreads();
27567 (arg1)->MoveAfterInTabOrder(arg2);
27568
27569 wxPyEndAllowThreads(__tstate);
27570 if (PyErr_Occurred()) SWIG_fail;
27571 }
27572 Py_INCREF(Py_None); resultobj = Py_None;
27573 return resultobj;
27574 fail:
27575 return NULL;
27576 }
27577
27578
27579 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27580 PyObject *resultobj;
27581 wxWindow *arg1 = (wxWindow *) 0 ;
27582 wxWindow *arg2 = (wxWindow *) 0 ;
27583 PyObject * obj0 = 0 ;
27584 PyObject * obj1 = 0 ;
27585 char *kwnames[] = {
27586 (char *) "self",(char *) "win", NULL
27587 };
27588
27589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27591 if (SWIG_arg_fail(1)) SWIG_fail;
27592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27593 if (SWIG_arg_fail(2)) SWIG_fail;
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 (arg1)->MoveBeforeInTabOrder(arg2);
27597
27598 wxPyEndAllowThreads(__tstate);
27599 if (PyErr_Occurred()) SWIG_fail;
27600 }
27601 Py_INCREF(Py_None); resultobj = Py_None;
27602 return resultobj;
27603 fail:
27604 return NULL;
27605 }
27606
27607
27608 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27609 PyObject *resultobj;
27610 wxWindow *arg1 = (wxWindow *) 0 ;
27611 PyObject *result;
27612 PyObject * obj0 = 0 ;
27613 char *kwnames[] = {
27614 (char *) "self", NULL
27615 };
27616
27617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27619 if (SWIG_arg_fail(1)) SWIG_fail;
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 result = (PyObject *)wxWindow_GetChildren(arg1);
27623
27624 wxPyEndAllowThreads(__tstate);
27625 if (PyErr_Occurred()) SWIG_fail;
27626 }
27627 resultobj = result;
27628 return resultobj;
27629 fail:
27630 return NULL;
27631 }
27632
27633
27634 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27635 PyObject *resultobj;
27636 wxWindow *arg1 = (wxWindow *) 0 ;
27637 wxWindow *result;
27638 PyObject * obj0 = 0 ;
27639 char *kwnames[] = {
27640 (char *) "self", NULL
27641 };
27642
27643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27645 if (SWIG_arg_fail(1)) SWIG_fail;
27646 {
27647 PyThreadState* __tstate = wxPyBeginAllowThreads();
27648 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27649
27650 wxPyEndAllowThreads(__tstate);
27651 if (PyErr_Occurred()) SWIG_fail;
27652 }
27653 {
27654 resultobj = wxPyMake_wxObject(result, 0);
27655 }
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27663 PyObject *resultobj;
27664 wxWindow *arg1 = (wxWindow *) 0 ;
27665 wxWindow *result;
27666 PyObject * obj0 = 0 ;
27667 char *kwnames[] = {
27668 (char *) "self", NULL
27669 };
27670
27671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27673 if (SWIG_arg_fail(1)) SWIG_fail;
27674 {
27675 PyThreadState* __tstate = wxPyBeginAllowThreads();
27676 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27677
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 {
27682 resultobj = wxPyMake_wxObject(result, 0);
27683 }
27684 return resultobj;
27685 fail:
27686 return NULL;
27687 }
27688
27689
27690 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27691 PyObject *resultobj;
27692 wxWindow *arg1 = (wxWindow *) 0 ;
27693 bool result;
27694 PyObject * obj0 = 0 ;
27695 char *kwnames[] = {
27696 (char *) "self", NULL
27697 };
27698
27699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27701 if (SWIG_arg_fail(1)) SWIG_fail;
27702 {
27703 PyThreadState* __tstate = wxPyBeginAllowThreads();
27704 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27705
27706 wxPyEndAllowThreads(__tstate);
27707 if (PyErr_Occurred()) SWIG_fail;
27708 }
27709 {
27710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27711 }
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27719 PyObject *resultobj;
27720 wxWindow *arg1 = (wxWindow *) 0 ;
27721 wxWindow *arg2 = (wxWindow *) 0 ;
27722 bool result;
27723 PyObject * obj0 = 0 ;
27724 PyObject * obj1 = 0 ;
27725 char *kwnames[] = {
27726 (char *) "self",(char *) "newParent", NULL
27727 };
27728
27729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27731 if (SWIG_arg_fail(1)) SWIG_fail;
27732 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27733 if (SWIG_arg_fail(2)) SWIG_fail;
27734 {
27735 PyThreadState* __tstate = wxPyBeginAllowThreads();
27736 result = (bool)(arg1)->Reparent(arg2);
27737
27738 wxPyEndAllowThreads(__tstate);
27739 if (PyErr_Occurred()) SWIG_fail;
27740 }
27741 {
27742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27743 }
27744 return resultobj;
27745 fail:
27746 return NULL;
27747 }
27748
27749
27750 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27751 PyObject *resultobj;
27752 wxWindow *arg1 = (wxWindow *) 0 ;
27753 wxWindow *arg2 = (wxWindow *) 0 ;
27754 PyObject * obj0 = 0 ;
27755 PyObject * obj1 = 0 ;
27756 char *kwnames[] = {
27757 (char *) "self",(char *) "child", NULL
27758 };
27759
27760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27762 if (SWIG_arg_fail(1)) SWIG_fail;
27763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27764 if (SWIG_arg_fail(2)) SWIG_fail;
27765 {
27766 PyThreadState* __tstate = wxPyBeginAllowThreads();
27767 (arg1)->AddChild(arg2);
27768
27769 wxPyEndAllowThreads(__tstate);
27770 if (PyErr_Occurred()) SWIG_fail;
27771 }
27772 Py_INCREF(Py_None); resultobj = Py_None;
27773 return resultobj;
27774 fail:
27775 return NULL;
27776 }
27777
27778
27779 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27780 PyObject *resultobj;
27781 wxWindow *arg1 = (wxWindow *) 0 ;
27782 wxWindow *arg2 = (wxWindow *) 0 ;
27783 PyObject * obj0 = 0 ;
27784 PyObject * obj1 = 0 ;
27785 char *kwnames[] = {
27786 (char *) "self",(char *) "child", NULL
27787 };
27788
27789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27791 if (SWIG_arg_fail(1)) SWIG_fail;
27792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27793 if (SWIG_arg_fail(2)) SWIG_fail;
27794 {
27795 PyThreadState* __tstate = wxPyBeginAllowThreads();
27796 (arg1)->RemoveChild(arg2);
27797
27798 wxPyEndAllowThreads(__tstate);
27799 if (PyErr_Occurred()) SWIG_fail;
27800 }
27801 Py_INCREF(Py_None); resultobj = Py_None;
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27809 PyObject *resultobj;
27810 wxWindow *arg1 = (wxWindow *) 0 ;
27811 long arg2 ;
27812 wxWindow *result;
27813 PyObject * obj0 = 0 ;
27814 PyObject * obj1 = 0 ;
27815 char *kwnames[] = {
27816 (char *) "self",(char *) "winid", NULL
27817 };
27818
27819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27821 if (SWIG_arg_fail(1)) SWIG_fail;
27822 {
27823 arg2 = (long)(SWIG_As_long(obj1));
27824 if (SWIG_arg_fail(2)) SWIG_fail;
27825 }
27826 {
27827 PyThreadState* __tstate = wxPyBeginAllowThreads();
27828 result = (wxWindow *)(arg1)->FindWindow(arg2);
27829
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 {
27834 resultobj = wxPyMake_wxObject(result, 0);
27835 }
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27843 PyObject *resultobj;
27844 wxWindow *arg1 = (wxWindow *) 0 ;
27845 wxString *arg2 = 0 ;
27846 wxWindow *result;
27847 bool temp2 = false ;
27848 PyObject * obj0 = 0 ;
27849 PyObject * obj1 = 0 ;
27850 char *kwnames[] = {
27851 (char *) "self",(char *) "name", NULL
27852 };
27853
27854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27856 if (SWIG_arg_fail(1)) SWIG_fail;
27857 {
27858 arg2 = wxString_in_helper(obj1);
27859 if (arg2 == NULL) SWIG_fail;
27860 temp2 = true;
27861 }
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27865
27866 wxPyEndAllowThreads(__tstate);
27867 if (PyErr_Occurred()) SWIG_fail;
27868 }
27869 {
27870 resultobj = wxPyMake_wxObject(result, 0);
27871 }
27872 {
27873 if (temp2)
27874 delete arg2;
27875 }
27876 return resultobj;
27877 fail:
27878 {
27879 if (temp2)
27880 delete arg2;
27881 }
27882 return NULL;
27883 }
27884
27885
27886 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj;
27888 wxWindow *arg1 = (wxWindow *) 0 ;
27889 wxEvtHandler *result;
27890 PyObject * obj0 = 0 ;
27891 char *kwnames[] = {
27892 (char *) "self", NULL
27893 };
27894
27895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27897 if (SWIG_arg_fail(1)) SWIG_fail;
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27901
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 {
27906 resultobj = wxPyMake_wxObject(result, 0);
27907 }
27908 return resultobj;
27909 fail:
27910 return NULL;
27911 }
27912
27913
27914 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27915 PyObject *resultobj;
27916 wxWindow *arg1 = (wxWindow *) 0 ;
27917 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27918 PyObject * obj0 = 0 ;
27919 PyObject * obj1 = 0 ;
27920 char *kwnames[] = {
27921 (char *) "self",(char *) "handler", NULL
27922 };
27923
27924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27926 if (SWIG_arg_fail(1)) SWIG_fail;
27927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27928 if (SWIG_arg_fail(2)) SWIG_fail;
27929 {
27930 PyThreadState* __tstate = wxPyBeginAllowThreads();
27931 (arg1)->SetEventHandler(arg2);
27932
27933 wxPyEndAllowThreads(__tstate);
27934 if (PyErr_Occurred()) SWIG_fail;
27935 }
27936 Py_INCREF(Py_None); resultobj = Py_None;
27937 return resultobj;
27938 fail:
27939 return NULL;
27940 }
27941
27942
27943 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27944 PyObject *resultobj;
27945 wxWindow *arg1 = (wxWindow *) 0 ;
27946 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27947 PyObject * obj0 = 0 ;
27948 PyObject * obj1 = 0 ;
27949 char *kwnames[] = {
27950 (char *) "self",(char *) "handler", NULL
27951 };
27952
27953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27955 if (SWIG_arg_fail(1)) SWIG_fail;
27956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27957 if (SWIG_arg_fail(2)) SWIG_fail;
27958 {
27959 PyThreadState* __tstate = wxPyBeginAllowThreads();
27960 (arg1)->PushEventHandler(arg2);
27961
27962 wxPyEndAllowThreads(__tstate);
27963 if (PyErr_Occurred()) SWIG_fail;
27964 }
27965 Py_INCREF(Py_None); resultobj = Py_None;
27966 return resultobj;
27967 fail:
27968 return NULL;
27969 }
27970
27971
27972 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27973 PyObject *resultobj;
27974 wxWindow *arg1 = (wxWindow *) 0 ;
27975 bool arg2 = (bool) false ;
27976 wxEvtHandler *result;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char *kwnames[] = {
27980 (char *) "self",(char *) "deleteHandler", NULL
27981 };
27982
27983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27985 if (SWIG_arg_fail(1)) SWIG_fail;
27986 if (obj1) {
27987 {
27988 arg2 = (bool)(SWIG_As_bool(obj1));
27989 if (SWIG_arg_fail(2)) SWIG_fail;
27990 }
27991 }
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27995
27996 wxPyEndAllowThreads(__tstate);
27997 if (PyErr_Occurred()) SWIG_fail;
27998 }
27999 {
28000 resultobj = wxPyMake_wxObject(result, 0);
28001 }
28002 return resultobj;
28003 fail:
28004 return NULL;
28005 }
28006
28007
28008 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28009 PyObject *resultobj;
28010 wxWindow *arg1 = (wxWindow *) 0 ;
28011 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28012 bool result;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 char *kwnames[] = {
28016 (char *) "self",(char *) "handler", NULL
28017 };
28018
28019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28021 if (SWIG_arg_fail(1)) SWIG_fail;
28022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28023 if (SWIG_arg_fail(2)) SWIG_fail;
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 result = (bool)(arg1)->RemoveEventHandler(arg2);
28027
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 {
28032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28033 }
28034 return resultobj;
28035 fail:
28036 return NULL;
28037 }
28038
28039
28040 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28041 PyObject *resultobj;
28042 wxWindow *arg1 = (wxWindow *) 0 ;
28043 wxValidator *arg2 = 0 ;
28044 PyObject * obj0 = 0 ;
28045 PyObject * obj1 = 0 ;
28046 char *kwnames[] = {
28047 (char *) "self",(char *) "validator", NULL
28048 };
28049
28050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28052 if (SWIG_arg_fail(1)) SWIG_fail;
28053 {
28054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28055 if (SWIG_arg_fail(2)) SWIG_fail;
28056 if (arg2 == NULL) {
28057 SWIG_null_ref("wxValidator");
28058 }
28059 if (SWIG_arg_fail(2)) SWIG_fail;
28060 }
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 (arg1)->SetValidator((wxValidator const &)*arg2);
28064
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 Py_INCREF(Py_None); resultobj = Py_None;
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj;
28077 wxWindow *arg1 = (wxWindow *) 0 ;
28078 wxValidator *result;
28079 PyObject * obj0 = 0 ;
28080 char *kwnames[] = {
28081 (char *) "self", NULL
28082 };
28083
28084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28086 if (SWIG_arg_fail(1)) SWIG_fail;
28087 {
28088 PyThreadState* __tstate = wxPyBeginAllowThreads();
28089 result = (wxValidator *)(arg1)->GetValidator();
28090
28091 wxPyEndAllowThreads(__tstate);
28092 if (PyErr_Occurred()) SWIG_fail;
28093 }
28094 {
28095 resultobj = wxPyMake_wxObject(result, 0);
28096 }
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj;
28105 wxWindow *arg1 = (wxWindow *) 0 ;
28106 bool result;
28107 PyObject * obj0 = 0 ;
28108 char *kwnames[] = {
28109 (char *) "self", NULL
28110 };
28111
28112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28114 if (SWIG_arg_fail(1)) SWIG_fail;
28115 {
28116 PyThreadState* __tstate = wxPyBeginAllowThreads();
28117 result = (bool)(arg1)->Validate();
28118
28119 wxPyEndAllowThreads(__tstate);
28120 if (PyErr_Occurred()) SWIG_fail;
28121 }
28122 {
28123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28124 }
28125 return resultobj;
28126 fail:
28127 return NULL;
28128 }
28129
28130
28131 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28132 PyObject *resultobj;
28133 wxWindow *arg1 = (wxWindow *) 0 ;
28134 bool result;
28135 PyObject * obj0 = 0 ;
28136 char *kwnames[] = {
28137 (char *) "self", NULL
28138 };
28139
28140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28142 if (SWIG_arg_fail(1)) SWIG_fail;
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 result = (bool)(arg1)->TransferDataToWindow();
28146
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 {
28151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28152 }
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28160 PyObject *resultobj;
28161 wxWindow *arg1 = (wxWindow *) 0 ;
28162 bool result;
28163 PyObject * obj0 = 0 ;
28164 char *kwnames[] = {
28165 (char *) "self", NULL
28166 };
28167
28168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28170 if (SWIG_arg_fail(1)) SWIG_fail;
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 result = (bool)(arg1)->TransferDataFromWindow();
28174
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 {
28179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28180 }
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28188 PyObject *resultobj;
28189 wxWindow *arg1 = (wxWindow *) 0 ;
28190 PyObject * obj0 = 0 ;
28191 char *kwnames[] = {
28192 (char *) "self", NULL
28193 };
28194
28195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28197 if (SWIG_arg_fail(1)) SWIG_fail;
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 (arg1)->InitDialog();
28201
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 Py_INCREF(Py_None); resultobj = Py_None;
28206 return resultobj;
28207 fail:
28208 return NULL;
28209 }
28210
28211
28212 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28213 PyObject *resultobj;
28214 wxWindow *arg1 = (wxWindow *) 0 ;
28215 wxAcceleratorTable *arg2 = 0 ;
28216 PyObject * obj0 = 0 ;
28217 PyObject * obj1 = 0 ;
28218 char *kwnames[] = {
28219 (char *) "self",(char *) "accel", NULL
28220 };
28221
28222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28224 if (SWIG_arg_fail(1)) SWIG_fail;
28225 {
28226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28227 if (SWIG_arg_fail(2)) SWIG_fail;
28228 if (arg2 == NULL) {
28229 SWIG_null_ref("wxAcceleratorTable");
28230 }
28231 if (SWIG_arg_fail(2)) SWIG_fail;
28232 }
28233 {
28234 PyThreadState* __tstate = wxPyBeginAllowThreads();
28235 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28236
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 Py_INCREF(Py_None); resultobj = Py_None;
28241 return resultobj;
28242 fail:
28243 return NULL;
28244 }
28245
28246
28247 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28248 PyObject *resultobj;
28249 wxWindow *arg1 = (wxWindow *) 0 ;
28250 wxAcceleratorTable *result;
28251 PyObject * obj0 = 0 ;
28252 char *kwnames[] = {
28253 (char *) "self", NULL
28254 };
28255
28256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28258 if (SWIG_arg_fail(1)) SWIG_fail;
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28262
28263 wxPyEndAllowThreads(__tstate);
28264 if (PyErr_Occurred()) SWIG_fail;
28265 }
28266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28267 return resultobj;
28268 fail:
28269 return NULL;
28270 }
28271
28272
28273 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28274 PyObject *resultobj;
28275 wxWindow *arg1 = (wxWindow *) 0 ;
28276 int arg2 ;
28277 int arg3 ;
28278 int arg4 ;
28279 bool result;
28280 PyObject * obj0 = 0 ;
28281 PyObject * obj1 = 0 ;
28282 PyObject * obj2 = 0 ;
28283 PyObject * obj3 = 0 ;
28284 char *kwnames[] = {
28285 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28286 };
28287
28288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28290 if (SWIG_arg_fail(1)) SWIG_fail;
28291 {
28292 arg2 = (int)(SWIG_As_int(obj1));
28293 if (SWIG_arg_fail(2)) SWIG_fail;
28294 }
28295 {
28296 arg3 = (int)(SWIG_As_int(obj2));
28297 if (SWIG_arg_fail(3)) SWIG_fail;
28298 }
28299 {
28300 arg4 = (int)(SWIG_As_int(obj3));
28301 if (SWIG_arg_fail(4)) SWIG_fail;
28302 }
28303 {
28304 PyThreadState* __tstate = wxPyBeginAllowThreads();
28305 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28306
28307 wxPyEndAllowThreads(__tstate);
28308 if (PyErr_Occurred()) SWIG_fail;
28309 }
28310 {
28311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28312 }
28313 return resultobj;
28314 fail:
28315 return NULL;
28316 }
28317
28318
28319 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28320 PyObject *resultobj;
28321 wxWindow *arg1 = (wxWindow *) 0 ;
28322 int arg2 ;
28323 bool result;
28324 PyObject * obj0 = 0 ;
28325 PyObject * obj1 = 0 ;
28326 char *kwnames[] = {
28327 (char *) "self",(char *) "hotkeyId", NULL
28328 };
28329
28330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28332 if (SWIG_arg_fail(1)) SWIG_fail;
28333 {
28334 arg2 = (int)(SWIG_As_int(obj1));
28335 if (SWIG_arg_fail(2)) SWIG_fail;
28336 }
28337 {
28338 PyThreadState* __tstate = wxPyBeginAllowThreads();
28339 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28340
28341 wxPyEndAllowThreads(__tstate);
28342 if (PyErr_Occurred()) SWIG_fail;
28343 }
28344 {
28345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28346 }
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28354 PyObject *resultobj;
28355 wxWindow *arg1 = (wxWindow *) 0 ;
28356 wxPoint *arg2 = 0 ;
28357 wxPoint result;
28358 wxPoint temp2 ;
28359 PyObject * obj0 = 0 ;
28360 PyObject * obj1 = 0 ;
28361 char *kwnames[] = {
28362 (char *) "self",(char *) "pt", NULL
28363 };
28364
28365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28367 if (SWIG_arg_fail(1)) SWIG_fail;
28368 {
28369 arg2 = &temp2;
28370 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28371 }
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28375
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 {
28380 wxPoint * resultptr;
28381 resultptr = new wxPoint((wxPoint &)(result));
28382 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28383 }
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28391 PyObject *resultobj;
28392 wxWindow *arg1 = (wxWindow *) 0 ;
28393 wxSize *arg2 = 0 ;
28394 wxSize result;
28395 wxSize temp2 ;
28396 PyObject * obj0 = 0 ;
28397 PyObject * obj1 = 0 ;
28398 char *kwnames[] = {
28399 (char *) "self",(char *) "sz", NULL
28400 };
28401
28402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28404 if (SWIG_arg_fail(1)) SWIG_fail;
28405 {
28406 arg2 = &temp2;
28407 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28408 }
28409 {
28410 PyThreadState* __tstate = wxPyBeginAllowThreads();
28411 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28412
28413 wxPyEndAllowThreads(__tstate);
28414 if (PyErr_Occurred()) SWIG_fail;
28415 }
28416 {
28417 wxSize * resultptr;
28418 resultptr = new wxSize((wxSize &)(result));
28419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28420 }
28421 return resultobj;
28422 fail:
28423 return NULL;
28424 }
28425
28426
28427 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28428 PyObject *resultobj;
28429 wxWindow *arg1 = (wxWindow *) 0 ;
28430 wxPoint *arg2 = 0 ;
28431 wxPoint result;
28432 wxPoint temp2 ;
28433 PyObject * obj0 = 0 ;
28434 PyObject * obj1 = 0 ;
28435 char *kwnames[] = {
28436 (char *) "self",(char *) "pt", NULL
28437 };
28438
28439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28441 if (SWIG_arg_fail(1)) SWIG_fail;
28442 {
28443 arg2 = &temp2;
28444 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28445 }
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28449
28450 wxPyEndAllowThreads(__tstate);
28451 if (PyErr_Occurred()) SWIG_fail;
28452 }
28453 {
28454 wxPoint * resultptr;
28455 resultptr = new wxPoint((wxPoint &)(result));
28456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28457 }
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28465 PyObject *resultobj;
28466 wxWindow *arg1 = (wxWindow *) 0 ;
28467 wxSize *arg2 = 0 ;
28468 wxSize result;
28469 wxSize temp2 ;
28470 PyObject * obj0 = 0 ;
28471 PyObject * obj1 = 0 ;
28472 char *kwnames[] = {
28473 (char *) "self",(char *) "sz", NULL
28474 };
28475
28476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28478 if (SWIG_arg_fail(1)) SWIG_fail;
28479 {
28480 arg2 = &temp2;
28481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28482 }
28483 {
28484 PyThreadState* __tstate = wxPyBeginAllowThreads();
28485 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28486
28487 wxPyEndAllowThreads(__tstate);
28488 if (PyErr_Occurred()) SWIG_fail;
28489 }
28490 {
28491 wxSize * resultptr;
28492 resultptr = new wxSize((wxSize &)(result));
28493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28494 }
28495 return resultobj;
28496 fail:
28497 return NULL;
28498 }
28499
28500
28501 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28502 PyObject *resultobj;
28503 wxWindow *arg1 = (wxWindow *) 0 ;
28504 wxPoint *arg2 = 0 ;
28505 wxPoint result;
28506 wxPoint temp2 ;
28507 PyObject * obj0 = 0 ;
28508 PyObject * obj1 = 0 ;
28509 char *kwnames[] = {
28510 (char *) "self",(char *) "pt", NULL
28511 };
28512
28513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28515 if (SWIG_arg_fail(1)) SWIG_fail;
28516 {
28517 arg2 = &temp2;
28518 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28519 }
28520 {
28521 PyThreadState* __tstate = wxPyBeginAllowThreads();
28522 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28523
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 {
28528 wxPoint * resultptr;
28529 resultptr = new wxPoint((wxPoint &)(result));
28530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28531 }
28532 return resultobj;
28533 fail:
28534 return NULL;
28535 }
28536
28537
28538 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28539 PyObject *resultobj;
28540 wxWindow *arg1 = (wxWindow *) 0 ;
28541 wxSize *arg2 = 0 ;
28542 wxSize result;
28543 wxSize temp2 ;
28544 PyObject * obj0 = 0 ;
28545 PyObject * obj1 = 0 ;
28546 char *kwnames[] = {
28547 (char *) "self",(char *) "sz", NULL
28548 };
28549
28550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28552 if (SWIG_arg_fail(1)) SWIG_fail;
28553 {
28554 arg2 = &temp2;
28555 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28556 }
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28560
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 {
28565 wxSize * resultptr;
28566 resultptr = new wxSize((wxSize &)(result));
28567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28568 }
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28576 PyObject *resultobj;
28577 wxWindow *arg1 = (wxWindow *) 0 ;
28578 int arg2 ;
28579 int arg3 ;
28580 PyObject * obj0 = 0 ;
28581 PyObject * obj1 = 0 ;
28582 PyObject * obj2 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self",(char *) "x",(char *) "y", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(1)) SWIG_fail;
28590 {
28591 arg2 = (int)(SWIG_As_int(obj1));
28592 if (SWIG_arg_fail(2)) SWIG_fail;
28593 }
28594 {
28595 arg3 = (int)(SWIG_As_int(obj2));
28596 if (SWIG_arg_fail(3)) SWIG_fail;
28597 }
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 (arg1)->WarpPointer(arg2,arg3);
28601
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 Py_INCREF(Py_None); resultobj = Py_None;
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28613 PyObject *resultobj;
28614 wxWindow *arg1 = (wxWindow *) 0 ;
28615 PyObject * obj0 = 0 ;
28616 char *kwnames[] = {
28617 (char *) "self", NULL
28618 };
28619
28620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(1)) SWIG_fail;
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 (arg1)->CaptureMouse();
28626
28627 wxPyEndAllowThreads(__tstate);
28628 if (PyErr_Occurred()) SWIG_fail;
28629 }
28630 Py_INCREF(Py_None); resultobj = Py_None;
28631 return resultobj;
28632 fail:
28633 return NULL;
28634 }
28635
28636
28637 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28638 PyObject *resultobj;
28639 wxWindow *arg1 = (wxWindow *) 0 ;
28640 PyObject * obj0 = 0 ;
28641 char *kwnames[] = {
28642 (char *) "self", NULL
28643 };
28644
28645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28647 if (SWIG_arg_fail(1)) SWIG_fail;
28648 {
28649 PyThreadState* __tstate = wxPyBeginAllowThreads();
28650 (arg1)->ReleaseMouse();
28651
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 Py_INCREF(Py_None); resultobj = Py_None;
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj;
28664 wxWindow *result;
28665 char *kwnames[] = {
28666 NULL
28667 };
28668
28669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28670 {
28671 if (!wxPyCheckForApp()) SWIG_fail;
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 result = (wxWindow *)wxWindow::GetCapture();
28674
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 {
28679 resultobj = wxPyMake_wxObject(result, 0);
28680 }
28681 return resultobj;
28682 fail:
28683 return NULL;
28684 }
28685
28686
28687 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28688 PyObject *resultobj;
28689 wxWindow *arg1 = (wxWindow *) 0 ;
28690 bool result;
28691 PyObject * obj0 = 0 ;
28692 char *kwnames[] = {
28693 (char *) "self", NULL
28694 };
28695
28696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28698 if (SWIG_arg_fail(1)) SWIG_fail;
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 result = (bool)((wxWindow const *)arg1)->HasCapture();
28702
28703 wxPyEndAllowThreads(__tstate);
28704 if (PyErr_Occurred()) SWIG_fail;
28705 }
28706 {
28707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28708 }
28709 return resultobj;
28710 fail:
28711 return NULL;
28712 }
28713
28714
28715 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28716 PyObject *resultobj;
28717 wxWindow *arg1 = (wxWindow *) 0 ;
28718 bool arg2 = (bool) true ;
28719 wxRect *arg3 = (wxRect *) NULL ;
28720 PyObject * obj0 = 0 ;
28721 PyObject * obj1 = 0 ;
28722 PyObject * obj2 = 0 ;
28723 char *kwnames[] = {
28724 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28725 };
28726
28727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28729 if (SWIG_arg_fail(1)) SWIG_fail;
28730 if (obj1) {
28731 {
28732 arg2 = (bool)(SWIG_As_bool(obj1));
28733 if (SWIG_arg_fail(2)) SWIG_fail;
28734 }
28735 }
28736 if (obj2) {
28737 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28738 if (SWIG_arg_fail(3)) SWIG_fail;
28739 }
28740 {
28741 PyThreadState* __tstate = wxPyBeginAllowThreads();
28742 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28743
28744 wxPyEndAllowThreads(__tstate);
28745 if (PyErr_Occurred()) SWIG_fail;
28746 }
28747 Py_INCREF(Py_None); resultobj = Py_None;
28748 return resultobj;
28749 fail:
28750 return NULL;
28751 }
28752
28753
28754 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28755 PyObject *resultobj;
28756 wxWindow *arg1 = (wxWindow *) 0 ;
28757 wxRect *arg2 = 0 ;
28758 bool arg3 = (bool) true ;
28759 wxRect temp2 ;
28760 PyObject * obj0 = 0 ;
28761 PyObject * obj1 = 0 ;
28762 PyObject * obj2 = 0 ;
28763 char *kwnames[] = {
28764 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28765 };
28766
28767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28769 if (SWIG_arg_fail(1)) SWIG_fail;
28770 {
28771 arg2 = &temp2;
28772 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28773 }
28774 if (obj2) {
28775 {
28776 arg3 = (bool)(SWIG_As_bool(obj2));
28777 if (SWIG_arg_fail(3)) SWIG_fail;
28778 }
28779 }
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28783
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 Py_INCREF(Py_None); resultobj = Py_None;
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj;
28796 wxWindow *arg1 = (wxWindow *) 0 ;
28797 PyObject * obj0 = 0 ;
28798 char *kwnames[] = {
28799 (char *) "self", NULL
28800 };
28801
28802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28804 if (SWIG_arg_fail(1)) SWIG_fail;
28805 {
28806 PyThreadState* __tstate = wxPyBeginAllowThreads();
28807 (arg1)->Update();
28808
28809 wxPyEndAllowThreads(__tstate);
28810 if (PyErr_Occurred()) SWIG_fail;
28811 }
28812 Py_INCREF(Py_None); resultobj = Py_None;
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28820 PyObject *resultobj;
28821 wxWindow *arg1 = (wxWindow *) 0 ;
28822 PyObject * obj0 = 0 ;
28823 char *kwnames[] = {
28824 (char *) "self", NULL
28825 };
28826
28827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28829 if (SWIG_arg_fail(1)) SWIG_fail;
28830 {
28831 PyThreadState* __tstate = wxPyBeginAllowThreads();
28832 (arg1)->ClearBackground();
28833
28834 wxPyEndAllowThreads(__tstate);
28835 if (PyErr_Occurred()) SWIG_fail;
28836 }
28837 Py_INCREF(Py_None); resultobj = Py_None;
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28845 PyObject *resultobj;
28846 wxWindow *arg1 = (wxWindow *) 0 ;
28847 PyObject * obj0 = 0 ;
28848 char *kwnames[] = {
28849 (char *) "self", NULL
28850 };
28851
28852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28854 if (SWIG_arg_fail(1)) SWIG_fail;
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 (arg1)->Freeze();
28858
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 Py_INCREF(Py_None); resultobj = Py_None;
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28870 PyObject *resultobj;
28871 wxWindow *arg1 = (wxWindow *) 0 ;
28872 PyObject * obj0 = 0 ;
28873 char *kwnames[] = {
28874 (char *) "self", NULL
28875 };
28876
28877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28879 if (SWIG_arg_fail(1)) SWIG_fail;
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 (arg1)->Thaw();
28883
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 Py_INCREF(Py_None); resultobj = Py_None;
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28895 PyObject *resultobj;
28896 wxWindow *arg1 = (wxWindow *) 0 ;
28897 wxDC *arg2 = 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 char *kwnames[] = {
28901 (char *) "self",(char *) "dc", NULL
28902 };
28903
28904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28906 if (SWIG_arg_fail(1)) SWIG_fail;
28907 {
28908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28909 if (SWIG_arg_fail(2)) SWIG_fail;
28910 if (arg2 == NULL) {
28911 SWIG_null_ref("wxDC");
28912 }
28913 if (SWIG_arg_fail(2)) SWIG_fail;
28914 }
28915 {
28916 PyThreadState* __tstate = wxPyBeginAllowThreads();
28917 (arg1)->PrepareDC(*arg2);
28918
28919 wxPyEndAllowThreads(__tstate);
28920 if (PyErr_Occurred()) SWIG_fail;
28921 }
28922 Py_INCREF(Py_None); resultobj = Py_None;
28923 return resultobj;
28924 fail:
28925 return NULL;
28926 }
28927
28928
28929 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28930 PyObject *resultobj;
28931 wxWindow *arg1 = (wxWindow *) 0 ;
28932 wxRegion *result;
28933 PyObject * obj0 = 0 ;
28934 char *kwnames[] = {
28935 (char *) "self", NULL
28936 };
28937
28938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28940 if (SWIG_arg_fail(1)) SWIG_fail;
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 {
28944 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28945 result = (wxRegion *) &_result_ref;
28946 }
28947
28948 wxPyEndAllowThreads(__tstate);
28949 if (PyErr_Occurred()) SWIG_fail;
28950 }
28951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28959 PyObject *resultobj;
28960 wxWindow *arg1 = (wxWindow *) 0 ;
28961 wxRect result;
28962 PyObject * obj0 = 0 ;
28963 char *kwnames[] = {
28964 (char *) "self", NULL
28965 };
28966
28967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28969 if (SWIG_arg_fail(1)) SWIG_fail;
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 {
28978 wxRect * resultptr;
28979 resultptr = new wxRect((wxRect &)(result));
28980 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28981 }
28982 return resultobj;
28983 fail:
28984 return NULL;
28985 }
28986
28987
28988 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28989 PyObject *resultobj;
28990 wxWindow *arg1 = (wxWindow *) 0 ;
28991 int arg2 ;
28992 int arg3 ;
28993 int arg4 = (int) 1 ;
28994 int arg5 = (int) 1 ;
28995 bool result;
28996 PyObject * obj0 = 0 ;
28997 PyObject * obj1 = 0 ;
28998 PyObject * obj2 = 0 ;
28999 PyObject * obj3 = 0 ;
29000 PyObject * obj4 = 0 ;
29001 char *kwnames[] = {
29002 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29003 };
29004
29005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29007 if (SWIG_arg_fail(1)) SWIG_fail;
29008 {
29009 arg2 = (int)(SWIG_As_int(obj1));
29010 if (SWIG_arg_fail(2)) SWIG_fail;
29011 }
29012 {
29013 arg3 = (int)(SWIG_As_int(obj2));
29014 if (SWIG_arg_fail(3)) SWIG_fail;
29015 }
29016 if (obj3) {
29017 {
29018 arg4 = (int)(SWIG_As_int(obj3));
29019 if (SWIG_arg_fail(4)) SWIG_fail;
29020 }
29021 }
29022 if (obj4) {
29023 {
29024 arg5 = (int)(SWIG_As_int(obj4));
29025 if (SWIG_arg_fail(5)) SWIG_fail;
29026 }
29027 }
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29031
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 {
29036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29037 }
29038 return resultobj;
29039 fail:
29040 return NULL;
29041 }
29042
29043
29044 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29045 PyObject *resultobj;
29046 wxWindow *arg1 = (wxWindow *) 0 ;
29047 wxPoint *arg2 = 0 ;
29048 bool result;
29049 wxPoint temp2 ;
29050 PyObject * obj0 = 0 ;
29051 PyObject * obj1 = 0 ;
29052 char *kwnames[] = {
29053 (char *) "self",(char *) "pt", NULL
29054 };
29055
29056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29058 if (SWIG_arg_fail(1)) SWIG_fail;
29059 {
29060 arg2 = &temp2;
29061 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29062 }
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29066
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 {
29071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29072 }
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj;
29081 wxWindow *arg1 = (wxWindow *) 0 ;
29082 wxRect *arg2 = 0 ;
29083 bool result;
29084 wxRect temp2 ;
29085 PyObject * obj0 = 0 ;
29086 PyObject * obj1 = 0 ;
29087 char *kwnames[] = {
29088 (char *) "self",(char *) "rect", NULL
29089 };
29090
29091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29093 if (SWIG_arg_fail(1)) SWIG_fail;
29094 {
29095 arg2 = &temp2;
29096 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29097 }
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29101
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 {
29106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29107 }
29108 return resultobj;
29109 fail:
29110 return NULL;
29111 }
29112
29113
29114 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29115 PyObject *resultobj;
29116 wxWindow *arg1 = (wxWindow *) 0 ;
29117 wxVisualAttributes result;
29118 PyObject * obj0 = 0 ;
29119 char *kwnames[] = {
29120 (char *) "self", NULL
29121 };
29122
29123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29125 if (SWIG_arg_fail(1)) SWIG_fail;
29126 {
29127 PyThreadState* __tstate = wxPyBeginAllowThreads();
29128 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29129
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 wxVisualAttributes * resultptr;
29135 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29137 }
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj;
29146 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29147 wxVisualAttributes result;
29148 PyObject * obj0 = 0 ;
29149 char *kwnames[] = {
29150 (char *) "variant", NULL
29151 };
29152
29153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29154 if (obj0) {
29155 {
29156 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29157 if (SWIG_arg_fail(1)) SWIG_fail;
29158 }
29159 }
29160 {
29161 if (!wxPyCheckForApp()) SWIG_fail;
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29164
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 {
29169 wxVisualAttributes * resultptr;
29170 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29172 }
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29180 PyObject *resultobj;
29181 wxWindow *arg1 = (wxWindow *) 0 ;
29182 wxColour *arg2 = 0 ;
29183 bool result;
29184 wxColour temp2 ;
29185 PyObject * obj0 = 0 ;
29186 PyObject * obj1 = 0 ;
29187 char *kwnames[] = {
29188 (char *) "self",(char *) "colour", NULL
29189 };
29190
29191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29193 if (SWIG_arg_fail(1)) SWIG_fail;
29194 {
29195 arg2 = &temp2;
29196 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29197 }
29198 {
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29201
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 {
29206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29207 }
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29215 PyObject *resultobj;
29216 wxWindow *arg1 = (wxWindow *) 0 ;
29217 wxColour *arg2 = 0 ;
29218 wxColour temp2 ;
29219 PyObject * obj0 = 0 ;
29220 PyObject * obj1 = 0 ;
29221 char *kwnames[] = {
29222 (char *) "self",(char *) "colour", NULL
29223 };
29224
29225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29227 if (SWIG_arg_fail(1)) SWIG_fail;
29228 {
29229 arg2 = &temp2;
29230 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29231 }
29232 {
29233 PyThreadState* __tstate = wxPyBeginAllowThreads();
29234 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29235
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 Py_INCREF(Py_None); resultobj = Py_None;
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxWindow *arg1 = (wxWindow *) 0 ;
29249 wxColour *arg2 = 0 ;
29250 bool result;
29251 wxColour temp2 ;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 char *kwnames[] = {
29255 (char *) "self",(char *) "colour", NULL
29256 };
29257
29258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29260 if (SWIG_arg_fail(1)) SWIG_fail;
29261 {
29262 arg2 = &temp2;
29263 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29264 }
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29268
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 {
29273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29274 }
29275 return resultobj;
29276 fail:
29277 return NULL;
29278 }
29279
29280
29281 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29282 PyObject *resultobj;
29283 wxWindow *arg1 = (wxWindow *) 0 ;
29284 wxColour *arg2 = 0 ;
29285 wxColour temp2 ;
29286 PyObject * obj0 = 0 ;
29287 PyObject * obj1 = 0 ;
29288 char *kwnames[] = {
29289 (char *) "self",(char *) "colour", NULL
29290 };
29291
29292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29294 if (SWIG_arg_fail(1)) SWIG_fail;
29295 {
29296 arg2 = &temp2;
29297 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29298 }
29299 {
29300 PyThreadState* __tstate = wxPyBeginAllowThreads();
29301 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29302
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 Py_INCREF(Py_None); resultobj = Py_None;
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29314 PyObject *resultobj;
29315 wxWindow *arg1 = (wxWindow *) 0 ;
29316 wxColour result;
29317 PyObject * obj0 = 0 ;
29318 char *kwnames[] = {
29319 (char *) "self", NULL
29320 };
29321
29322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29324 if (SWIG_arg_fail(1)) SWIG_fail;
29325 {
29326 PyThreadState* __tstate = wxPyBeginAllowThreads();
29327 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29328
29329 wxPyEndAllowThreads(__tstate);
29330 if (PyErr_Occurred()) SWIG_fail;
29331 }
29332 {
29333 wxColour * resultptr;
29334 resultptr = new wxColour((wxColour &)(result));
29335 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29336 }
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj;
29345 wxWindow *arg1 = (wxWindow *) 0 ;
29346 wxColour result;
29347 PyObject * obj0 = 0 ;
29348 char *kwnames[] = {
29349 (char *) "self", NULL
29350 };
29351
29352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29354 if (SWIG_arg_fail(1)) SWIG_fail;
29355 {
29356 PyThreadState* __tstate = wxPyBeginAllowThreads();
29357 result = ((wxWindow const *)arg1)->GetForegroundColour();
29358
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 {
29363 wxColour * resultptr;
29364 resultptr = new wxColour((wxColour &)(result));
29365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29366 }
29367 return resultobj;
29368 fail:
29369 return NULL;
29370 }
29371
29372
29373 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29374 PyObject *resultobj;
29375 wxWindow *arg1 = (wxWindow *) 0 ;
29376 wxBackgroundStyle arg2 ;
29377 bool result;
29378 PyObject * obj0 = 0 ;
29379 PyObject * obj1 = 0 ;
29380 char *kwnames[] = {
29381 (char *) "self",(char *) "style", NULL
29382 };
29383
29384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29386 if (SWIG_arg_fail(1)) SWIG_fail;
29387 {
29388 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29389 if (SWIG_arg_fail(2)) SWIG_fail;
29390 }
29391 {
29392 PyThreadState* __tstate = wxPyBeginAllowThreads();
29393 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29394
29395 wxPyEndAllowThreads(__tstate);
29396 if (PyErr_Occurred()) SWIG_fail;
29397 }
29398 {
29399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29400 }
29401 return resultobj;
29402 fail:
29403 return NULL;
29404 }
29405
29406
29407 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29408 PyObject *resultobj;
29409 wxWindow *arg1 = (wxWindow *) 0 ;
29410 wxBackgroundStyle result;
29411 PyObject * obj0 = 0 ;
29412 char *kwnames[] = {
29413 (char *) "self", NULL
29414 };
29415
29416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29418 if (SWIG_arg_fail(1)) SWIG_fail;
29419 {
29420 PyThreadState* __tstate = wxPyBeginAllowThreads();
29421 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29422
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 resultobj = SWIG_From_int((result));
29427 return resultobj;
29428 fail:
29429 return NULL;
29430 }
29431
29432
29433 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29434 PyObject *resultobj;
29435 wxWindow *arg1 = (wxWindow *) 0 ;
29436 bool result;
29437 PyObject * obj0 = 0 ;
29438 char *kwnames[] = {
29439 (char *) "self", NULL
29440 };
29441
29442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29444 if (SWIG_arg_fail(1)) SWIG_fail;
29445 {
29446 PyThreadState* __tstate = wxPyBeginAllowThreads();
29447 result = (bool)(arg1)->HasTransparentBackground();
29448
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 {
29453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29454 }
29455 return resultobj;
29456 fail:
29457 return NULL;
29458 }
29459
29460
29461 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29462 PyObject *resultobj;
29463 wxWindow *arg1 = (wxWindow *) 0 ;
29464 wxCursor *arg2 = 0 ;
29465 bool result;
29466 PyObject * obj0 = 0 ;
29467 PyObject * obj1 = 0 ;
29468 char *kwnames[] = {
29469 (char *) "self",(char *) "cursor", NULL
29470 };
29471
29472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29474 if (SWIG_arg_fail(1)) SWIG_fail;
29475 {
29476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29477 if (SWIG_arg_fail(2)) SWIG_fail;
29478 if (arg2 == NULL) {
29479 SWIG_null_ref("wxCursor");
29480 }
29481 if (SWIG_arg_fail(2)) SWIG_fail;
29482 }
29483 {
29484 PyThreadState* __tstate = wxPyBeginAllowThreads();
29485 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29486
29487 wxPyEndAllowThreads(__tstate);
29488 if (PyErr_Occurred()) SWIG_fail;
29489 }
29490 {
29491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29492 }
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29500 PyObject *resultobj;
29501 wxWindow *arg1 = (wxWindow *) 0 ;
29502 wxCursor result;
29503 PyObject * obj0 = 0 ;
29504 char *kwnames[] = {
29505 (char *) "self", NULL
29506 };
29507
29508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29510 if (SWIG_arg_fail(1)) SWIG_fail;
29511 {
29512 PyThreadState* __tstate = wxPyBeginAllowThreads();
29513 result = (arg1)->GetCursor();
29514
29515 wxPyEndAllowThreads(__tstate);
29516 if (PyErr_Occurred()) SWIG_fail;
29517 }
29518 {
29519 wxCursor * resultptr;
29520 resultptr = new wxCursor((wxCursor &)(result));
29521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj;
29531 wxWindow *arg1 = (wxWindow *) 0 ;
29532 wxFont *arg2 = 0 ;
29533 bool result;
29534 PyObject * obj0 = 0 ;
29535 PyObject * obj1 = 0 ;
29536 char *kwnames[] = {
29537 (char *) "self",(char *) "font", NULL
29538 };
29539
29540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29545 if (SWIG_arg_fail(2)) SWIG_fail;
29546 if (arg2 == NULL) {
29547 SWIG_null_ref("wxFont");
29548 }
29549 if (SWIG_arg_fail(2)) SWIG_fail;
29550 }
29551 {
29552 PyThreadState* __tstate = wxPyBeginAllowThreads();
29553 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29554
29555 wxPyEndAllowThreads(__tstate);
29556 if (PyErr_Occurred()) SWIG_fail;
29557 }
29558 {
29559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29560 }
29561 return resultobj;
29562 fail:
29563 return NULL;
29564 }
29565
29566
29567 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29568 PyObject *resultobj;
29569 wxWindow *arg1 = (wxWindow *) 0 ;
29570 wxFont *arg2 = 0 ;
29571 PyObject * obj0 = 0 ;
29572 PyObject * obj1 = 0 ;
29573 char *kwnames[] = {
29574 (char *) "self",(char *) "font", NULL
29575 };
29576
29577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29579 if (SWIG_arg_fail(1)) SWIG_fail;
29580 {
29581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29582 if (SWIG_arg_fail(2)) SWIG_fail;
29583 if (arg2 == NULL) {
29584 SWIG_null_ref("wxFont");
29585 }
29586 if (SWIG_arg_fail(2)) SWIG_fail;
29587 }
29588 {
29589 PyThreadState* __tstate = wxPyBeginAllowThreads();
29590 (arg1)->SetOwnFont((wxFont const &)*arg2);
29591
29592 wxPyEndAllowThreads(__tstate);
29593 if (PyErr_Occurred()) SWIG_fail;
29594 }
29595 Py_INCREF(Py_None); resultobj = Py_None;
29596 return resultobj;
29597 fail:
29598 return NULL;
29599 }
29600
29601
29602 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29603 PyObject *resultobj;
29604 wxWindow *arg1 = (wxWindow *) 0 ;
29605 wxFont result;
29606 PyObject * obj0 = 0 ;
29607 char *kwnames[] = {
29608 (char *) "self", NULL
29609 };
29610
29611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29613 if (SWIG_arg_fail(1)) SWIG_fail;
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 result = (arg1)->GetFont();
29617
29618 wxPyEndAllowThreads(__tstate);
29619 if (PyErr_Occurred()) SWIG_fail;
29620 }
29621 {
29622 wxFont * resultptr;
29623 resultptr = new wxFont((wxFont &)(result));
29624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29625 }
29626 return resultobj;
29627 fail:
29628 return NULL;
29629 }
29630
29631
29632 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29633 PyObject *resultobj;
29634 wxWindow *arg1 = (wxWindow *) 0 ;
29635 wxCaret *arg2 = (wxCaret *) 0 ;
29636 PyObject * obj0 = 0 ;
29637 PyObject * obj1 = 0 ;
29638 char *kwnames[] = {
29639 (char *) "self",(char *) "caret", NULL
29640 };
29641
29642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29646 if (SWIG_arg_fail(2)) SWIG_fail;
29647 {
29648 PyThreadState* __tstate = wxPyBeginAllowThreads();
29649 (arg1)->SetCaret(arg2);
29650
29651 wxPyEndAllowThreads(__tstate);
29652 if (PyErr_Occurred()) SWIG_fail;
29653 }
29654 Py_INCREF(Py_None); resultobj = Py_None;
29655 return resultobj;
29656 fail:
29657 return NULL;
29658 }
29659
29660
29661 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29662 PyObject *resultobj;
29663 wxWindow *arg1 = (wxWindow *) 0 ;
29664 wxCaret *result;
29665 PyObject * obj0 = 0 ;
29666 char *kwnames[] = {
29667 (char *) "self", NULL
29668 };
29669
29670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29672 if (SWIG_arg_fail(1)) SWIG_fail;
29673 {
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29676
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29688 PyObject *resultobj;
29689 wxWindow *arg1 = (wxWindow *) 0 ;
29690 int result;
29691 PyObject * obj0 = 0 ;
29692 char *kwnames[] = {
29693 (char *) "self", NULL
29694 };
29695
29696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29698 if (SWIG_arg_fail(1)) SWIG_fail;
29699 {
29700 PyThreadState* __tstate = wxPyBeginAllowThreads();
29701 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29702
29703 wxPyEndAllowThreads(__tstate);
29704 if (PyErr_Occurred()) SWIG_fail;
29705 }
29706 {
29707 resultobj = SWIG_From_int((int)(result));
29708 }
29709 return resultobj;
29710 fail:
29711 return NULL;
29712 }
29713
29714
29715 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29716 PyObject *resultobj;
29717 wxWindow *arg1 = (wxWindow *) 0 ;
29718 int result;
29719 PyObject * obj0 = 0 ;
29720 char *kwnames[] = {
29721 (char *) "self", NULL
29722 };
29723
29724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29726 if (SWIG_arg_fail(1)) SWIG_fail;
29727 {
29728 PyThreadState* __tstate = wxPyBeginAllowThreads();
29729 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29730
29731 wxPyEndAllowThreads(__tstate);
29732 if (PyErr_Occurred()) SWIG_fail;
29733 }
29734 {
29735 resultobj = SWIG_From_int((int)(result));
29736 }
29737 return resultobj;
29738 fail:
29739 return NULL;
29740 }
29741
29742
29743 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29744 PyObject *resultobj;
29745 wxWindow *arg1 = (wxWindow *) 0 ;
29746 wxString *arg2 = 0 ;
29747 int *arg3 = (int *) 0 ;
29748 int *arg4 = (int *) 0 ;
29749 bool temp2 = false ;
29750 int temp3 ;
29751 int res3 = 0 ;
29752 int temp4 ;
29753 int res4 = 0 ;
29754 PyObject * obj0 = 0 ;
29755 PyObject * obj1 = 0 ;
29756 char *kwnames[] = {
29757 (char *) "self",(char *) "string", NULL
29758 };
29759
29760 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29761 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29764 if (SWIG_arg_fail(1)) SWIG_fail;
29765 {
29766 arg2 = wxString_in_helper(obj1);
29767 if (arg2 == NULL) SWIG_fail;
29768 temp2 = true;
29769 }
29770 {
29771 PyThreadState* __tstate = wxPyBeginAllowThreads();
29772 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29773
29774 wxPyEndAllowThreads(__tstate);
29775 if (PyErr_Occurred()) SWIG_fail;
29776 }
29777 Py_INCREF(Py_None); resultobj = Py_None;
29778 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29779 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29780 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29781 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29782 {
29783 if (temp2)
29784 delete arg2;
29785 }
29786 return resultobj;
29787 fail:
29788 {
29789 if (temp2)
29790 delete arg2;
29791 }
29792 return NULL;
29793 }
29794
29795
29796 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29797 PyObject *resultobj;
29798 wxWindow *arg1 = (wxWindow *) 0 ;
29799 wxString *arg2 = 0 ;
29800 int *arg3 = (int *) 0 ;
29801 int *arg4 = (int *) 0 ;
29802 int *arg5 = (int *) 0 ;
29803 int *arg6 = (int *) 0 ;
29804 wxFont *arg7 = (wxFont *) NULL ;
29805 bool temp2 = false ;
29806 int temp3 ;
29807 int res3 = 0 ;
29808 int temp4 ;
29809 int res4 = 0 ;
29810 int temp5 ;
29811 int res5 = 0 ;
29812 int temp6 ;
29813 int res6 = 0 ;
29814 PyObject * obj0 = 0 ;
29815 PyObject * obj1 = 0 ;
29816 PyObject * obj2 = 0 ;
29817 char *kwnames[] = {
29818 (char *) "self",(char *) "string",(char *) "font", NULL
29819 };
29820
29821 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29822 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29823 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29824 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29827 if (SWIG_arg_fail(1)) SWIG_fail;
29828 {
29829 arg2 = wxString_in_helper(obj1);
29830 if (arg2 == NULL) SWIG_fail;
29831 temp2 = true;
29832 }
29833 if (obj2) {
29834 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29835 if (SWIG_arg_fail(7)) SWIG_fail;
29836 }
29837 {
29838 PyThreadState* __tstate = wxPyBeginAllowThreads();
29839 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29840
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 Py_INCREF(Py_None); resultobj = Py_None;
29845 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29846 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29847 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29848 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29849 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29850 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29851 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29852 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29853 {
29854 if (temp2)
29855 delete arg2;
29856 }
29857 return resultobj;
29858 fail:
29859 {
29860 if (temp2)
29861 delete arg2;
29862 }
29863 return NULL;
29864 }
29865
29866
29867 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj;
29869 wxWindow *arg1 = (wxWindow *) 0 ;
29870 int *arg2 = (int *) 0 ;
29871 int *arg3 = (int *) 0 ;
29872 int temp2 ;
29873 int res2 = 0 ;
29874 int temp3 ;
29875 int res3 = 0 ;
29876 PyObject * obj0 = 0 ;
29877 PyObject * obj1 = 0 ;
29878 PyObject * obj2 = 0 ;
29879 char *kwnames[] = {
29880 (char *) "self",(char *) "x",(char *) "y", NULL
29881 };
29882
29883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29885 if (SWIG_arg_fail(1)) SWIG_fail;
29886 {
29887 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29888 temp2 = SWIG_As_int(obj1);
29889 if (SWIG_arg_fail(2)) SWIG_fail;
29890 arg2 = &temp2;
29891 res2 = SWIG_NEWOBJ;
29892 }
29893 }
29894 {
29895 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29896 temp3 = SWIG_As_int(obj2);
29897 if (SWIG_arg_fail(3)) SWIG_fail;
29898 arg3 = &temp3;
29899 res3 = SWIG_NEWOBJ;
29900 }
29901 }
29902 {
29903 PyThreadState* __tstate = wxPyBeginAllowThreads();
29904 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29905
29906 wxPyEndAllowThreads(__tstate);
29907 if (PyErr_Occurred()) SWIG_fail;
29908 }
29909 Py_INCREF(Py_None); resultobj = Py_None;
29910 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29911 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29912 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29913 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29921 PyObject *resultobj;
29922 wxWindow *arg1 = (wxWindow *) 0 ;
29923 int *arg2 = (int *) 0 ;
29924 int *arg3 = (int *) 0 ;
29925 int temp2 ;
29926 int res2 = 0 ;
29927 int temp3 ;
29928 int res3 = 0 ;
29929 PyObject * obj0 = 0 ;
29930 PyObject * obj1 = 0 ;
29931 PyObject * obj2 = 0 ;
29932 char *kwnames[] = {
29933 (char *) "self",(char *) "x",(char *) "y", NULL
29934 };
29935
29936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29938 if (SWIG_arg_fail(1)) SWIG_fail;
29939 {
29940 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29941 temp2 = SWIG_As_int(obj1);
29942 if (SWIG_arg_fail(2)) SWIG_fail;
29943 arg2 = &temp2;
29944 res2 = SWIG_NEWOBJ;
29945 }
29946 }
29947 {
29948 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29949 temp3 = SWIG_As_int(obj2);
29950 if (SWIG_arg_fail(3)) SWIG_fail;
29951 arg3 = &temp3;
29952 res3 = SWIG_NEWOBJ;
29953 }
29954 }
29955 {
29956 PyThreadState* __tstate = wxPyBeginAllowThreads();
29957 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29958
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 Py_INCREF(Py_None); resultobj = Py_None;
29963 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29964 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29965 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29966 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29974 PyObject *resultobj;
29975 wxWindow *arg1 = (wxWindow *) 0 ;
29976 wxPoint *arg2 = 0 ;
29977 wxPoint result;
29978 wxPoint temp2 ;
29979 PyObject * obj0 = 0 ;
29980 PyObject * obj1 = 0 ;
29981 char *kwnames[] = {
29982 (char *) "self",(char *) "pt", NULL
29983 };
29984
29985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29987 if (SWIG_arg_fail(1)) SWIG_fail;
29988 {
29989 arg2 = &temp2;
29990 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29991 }
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29995
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 {
30000 wxPoint * resultptr;
30001 resultptr = new wxPoint((wxPoint &)(result));
30002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30003 }
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30011 PyObject *resultobj;
30012 wxWindow *arg1 = (wxWindow *) 0 ;
30013 wxPoint *arg2 = 0 ;
30014 wxPoint result;
30015 wxPoint temp2 ;
30016 PyObject * obj0 = 0 ;
30017 PyObject * obj1 = 0 ;
30018 char *kwnames[] = {
30019 (char *) "self",(char *) "pt", NULL
30020 };
30021
30022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30024 if (SWIG_arg_fail(1)) SWIG_fail;
30025 {
30026 arg2 = &temp2;
30027 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30028 }
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30032
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 {
30037 wxPoint * resultptr;
30038 resultptr = new wxPoint((wxPoint &)(result));
30039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30040 }
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj;
30049 wxWindow *arg1 = (wxWindow *) 0 ;
30050 int arg2 ;
30051 int arg3 ;
30052 wxHitTest result;
30053 PyObject * obj0 = 0 ;
30054 PyObject * obj1 = 0 ;
30055 PyObject * obj2 = 0 ;
30056 char *kwnames[] = {
30057 (char *) "self",(char *) "x",(char *) "y", NULL
30058 };
30059
30060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30062 if (SWIG_arg_fail(1)) SWIG_fail;
30063 {
30064 arg2 = (int)(SWIG_As_int(obj1));
30065 if (SWIG_arg_fail(2)) SWIG_fail;
30066 }
30067 {
30068 arg3 = (int)(SWIG_As_int(obj2));
30069 if (SWIG_arg_fail(3)) SWIG_fail;
30070 }
30071 {
30072 PyThreadState* __tstate = wxPyBeginAllowThreads();
30073 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30074
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 resultobj = SWIG_From_int((result));
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30086 PyObject *resultobj;
30087 wxWindow *arg1 = (wxWindow *) 0 ;
30088 wxPoint *arg2 = 0 ;
30089 wxHitTest result;
30090 wxPoint temp2 ;
30091 PyObject * obj0 = 0 ;
30092 PyObject * obj1 = 0 ;
30093 char *kwnames[] = {
30094 (char *) "self",(char *) "pt", NULL
30095 };
30096
30097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30099 if (SWIG_arg_fail(1)) SWIG_fail;
30100 {
30101 arg2 = &temp2;
30102 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30103 }
30104 {
30105 PyThreadState* __tstate = wxPyBeginAllowThreads();
30106 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30107
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 resultobj = SWIG_From_int((result));
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30119 PyObject *resultobj;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 long arg2 ;
30122 wxBorder result;
30123 PyObject * obj0 = 0 ;
30124 PyObject * obj1 = 0 ;
30125
30126 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30128 if (SWIG_arg_fail(1)) SWIG_fail;
30129 {
30130 arg2 = (long)(SWIG_As_long(obj1));
30131 if (SWIG_arg_fail(2)) SWIG_fail;
30132 }
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30136
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 resultobj = SWIG_From_int((result));
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30148 PyObject *resultobj;
30149 wxWindow *arg1 = (wxWindow *) 0 ;
30150 wxBorder result;
30151 PyObject * obj0 = 0 ;
30152
30153 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30155 if (SWIG_arg_fail(1)) SWIG_fail;
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 resultobj = SWIG_From_int((result));
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30171 int argc;
30172 PyObject *argv[3];
30173 int ii;
30174
30175 argc = PyObject_Length(args);
30176 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30177 argv[ii] = PyTuple_GetItem(args,ii);
30178 }
30179 if (argc == 1) {
30180 int _v;
30181 {
30182 void *ptr;
30183 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30184 _v = 0;
30185 PyErr_Clear();
30186 } else {
30187 _v = 1;
30188 }
30189 }
30190 if (_v) {
30191 return _wrap_Window_GetBorder__SWIG_1(self,args);
30192 }
30193 }
30194 if (argc == 2) {
30195 int _v;
30196 {
30197 void *ptr;
30198 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30199 _v = 0;
30200 PyErr_Clear();
30201 } else {
30202 _v = 1;
30203 }
30204 }
30205 if (_v) {
30206 _v = SWIG_Check_long(argv[1]);
30207 if (_v) {
30208 return _wrap_Window_GetBorder__SWIG_0(self,args);
30209 }
30210 }
30211 }
30212
30213 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30214 return NULL;
30215 }
30216
30217
30218 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30219 PyObject *resultobj;
30220 wxWindow *arg1 = (wxWindow *) 0 ;
30221 long arg2 = (long) wxUPDATE_UI_NONE ;
30222 PyObject * obj0 = 0 ;
30223 PyObject * obj1 = 0 ;
30224 char *kwnames[] = {
30225 (char *) "self",(char *) "flags", NULL
30226 };
30227
30228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30230 if (SWIG_arg_fail(1)) SWIG_fail;
30231 if (obj1) {
30232 {
30233 arg2 = (long)(SWIG_As_long(obj1));
30234 if (SWIG_arg_fail(2)) SWIG_fail;
30235 }
30236 }
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 (arg1)->UpdateWindowUI(arg2);
30240
30241 wxPyEndAllowThreads(__tstate);
30242 if (PyErr_Occurred()) SWIG_fail;
30243 }
30244 Py_INCREF(Py_None); resultobj = Py_None;
30245 return resultobj;
30246 fail:
30247 return NULL;
30248 }
30249
30250
30251 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30252 PyObject *resultobj;
30253 wxWindow *arg1 = (wxWindow *) 0 ;
30254 wxMenu *arg2 = (wxMenu *) 0 ;
30255 int arg3 = (int) -1 ;
30256 int arg4 = (int) -1 ;
30257 bool result;
30258 PyObject * obj0 = 0 ;
30259 PyObject * obj1 = 0 ;
30260 PyObject * obj2 = 0 ;
30261 PyObject * obj3 = 0 ;
30262 char *kwnames[] = {
30263 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30264 };
30265
30266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30268 if (SWIG_arg_fail(1)) SWIG_fail;
30269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(2)) SWIG_fail;
30271 if (obj2) {
30272 {
30273 arg3 = (int)(SWIG_As_int(obj2));
30274 if (SWIG_arg_fail(3)) SWIG_fail;
30275 }
30276 }
30277 if (obj3) {
30278 {
30279 arg4 = (int)(SWIG_As_int(obj3));
30280 if (SWIG_arg_fail(4)) SWIG_fail;
30281 }
30282 }
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30286
30287 wxPyEndAllowThreads(__tstate);
30288 if (PyErr_Occurred()) SWIG_fail;
30289 }
30290 {
30291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30292 }
30293 return resultobj;
30294 fail:
30295 return NULL;
30296 }
30297
30298
30299 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30300 PyObject *resultobj;
30301 wxWindow *arg1 = (wxWindow *) 0 ;
30302 wxMenu *arg2 = (wxMenu *) 0 ;
30303 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30304 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30305 bool result;
30306 wxPoint temp3 ;
30307 PyObject * obj0 = 0 ;
30308 PyObject * obj1 = 0 ;
30309 PyObject * obj2 = 0 ;
30310 char *kwnames[] = {
30311 (char *) "self",(char *) "menu",(char *) "pos", NULL
30312 };
30313
30314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30316 if (SWIG_arg_fail(1)) SWIG_fail;
30317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30318 if (SWIG_arg_fail(2)) SWIG_fail;
30319 if (obj2) {
30320 {
30321 arg3 = &temp3;
30322 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30323 }
30324 }
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30328
30329 wxPyEndAllowThreads(__tstate);
30330 if (PyErr_Occurred()) SWIG_fail;
30331 }
30332 {
30333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30334 }
30335 return resultobj;
30336 fail:
30337 return NULL;
30338 }
30339
30340
30341 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj;
30343 wxWindow *arg1 = (wxWindow *) 0 ;
30344 long result;
30345 PyObject * obj0 = 0 ;
30346 char *kwnames[] = {
30347 (char *) "self", NULL
30348 };
30349
30350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30352 if (SWIG_arg_fail(1)) SWIG_fail;
30353 {
30354 PyThreadState* __tstate = wxPyBeginAllowThreads();
30355 result = (long)wxWindow_GetHandle(arg1);
30356
30357 wxPyEndAllowThreads(__tstate);
30358 if (PyErr_Occurred()) SWIG_fail;
30359 }
30360 {
30361 resultobj = SWIG_From_long((long)(result));
30362 }
30363 return resultobj;
30364 fail:
30365 return NULL;
30366 }
30367
30368
30369 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30370 PyObject *resultobj;
30371 wxWindow *arg1 = (wxWindow *) 0 ;
30372 long arg2 ;
30373 PyObject * obj0 = 0 ;
30374 PyObject * obj1 = 0 ;
30375 char *kwnames[] = {
30376 (char *) "self",(char *) "handle", NULL
30377 };
30378
30379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30381 if (SWIG_arg_fail(1)) SWIG_fail;
30382 {
30383 arg2 = (long)(SWIG_As_long(obj1));
30384 if (SWIG_arg_fail(2)) SWIG_fail;
30385 }
30386 {
30387 PyThreadState* __tstate = wxPyBeginAllowThreads();
30388 wxWindow_AssociateHandle(arg1,arg2);
30389
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 Py_INCREF(Py_None); resultobj = Py_None;
30394 return resultobj;
30395 fail:
30396 return NULL;
30397 }
30398
30399
30400 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30401 PyObject *resultobj;
30402 wxWindow *arg1 = (wxWindow *) 0 ;
30403 PyObject * obj0 = 0 ;
30404 char *kwnames[] = {
30405 (char *) "self", NULL
30406 };
30407
30408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 (arg1)->DissociateHandle();
30414
30415 wxPyEndAllowThreads(__tstate);
30416 if (PyErr_Occurred()) SWIG_fail;
30417 }
30418 Py_INCREF(Py_None); resultobj = Py_None;
30419 return resultobj;
30420 fail:
30421 return NULL;
30422 }
30423
30424
30425 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30426 PyObject *resultobj;
30427 wxWindow *arg1 = (wxWindow *) 0 ;
30428 wxPaintEvent *arg2 = 0 ;
30429 PyObject * obj0 = 0 ;
30430 PyObject * obj1 = 0 ;
30431 char *kwnames[] = {
30432 (char *) "self",(char *) "event", NULL
30433 };
30434
30435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30437 if (SWIG_arg_fail(1)) SWIG_fail;
30438 {
30439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30440 if (SWIG_arg_fail(2)) SWIG_fail;
30441 if (arg2 == NULL) {
30442 SWIG_null_ref("wxPaintEvent");
30443 }
30444 if (SWIG_arg_fail(2)) SWIG_fail;
30445 }
30446 {
30447 PyThreadState* __tstate = wxPyBeginAllowThreads();
30448 (arg1)->OnPaint(*arg2);
30449
30450 wxPyEndAllowThreads(__tstate);
30451 if (PyErr_Occurred()) SWIG_fail;
30452 }
30453 Py_INCREF(Py_None); resultobj = Py_None;
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj;
30462 wxWindow *arg1 = (wxWindow *) 0 ;
30463 int arg2 ;
30464 bool result;
30465 PyObject * obj0 = 0 ;
30466 PyObject * obj1 = 0 ;
30467 char *kwnames[] = {
30468 (char *) "self",(char *) "orient", NULL
30469 };
30470
30471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30473 if (SWIG_arg_fail(1)) SWIG_fail;
30474 {
30475 arg2 = (int)(SWIG_As_int(obj1));
30476 if (SWIG_arg_fail(2)) SWIG_fail;
30477 }
30478 {
30479 PyThreadState* __tstate = wxPyBeginAllowThreads();
30480 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30481
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 {
30486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30487 }
30488 return resultobj;
30489 fail:
30490 return NULL;
30491 }
30492
30493
30494 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30495 PyObject *resultobj;
30496 wxWindow *arg1 = (wxWindow *) 0 ;
30497 int arg2 ;
30498 int arg3 ;
30499 int arg4 ;
30500 int arg5 ;
30501 bool arg6 = (bool) true ;
30502 PyObject * obj0 = 0 ;
30503 PyObject * obj1 = 0 ;
30504 PyObject * obj2 = 0 ;
30505 PyObject * obj3 = 0 ;
30506 PyObject * obj4 = 0 ;
30507 PyObject * obj5 = 0 ;
30508 char *kwnames[] = {
30509 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30510 };
30511
30512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30514 if (SWIG_arg_fail(1)) SWIG_fail;
30515 {
30516 arg2 = (int)(SWIG_As_int(obj1));
30517 if (SWIG_arg_fail(2)) SWIG_fail;
30518 }
30519 {
30520 arg3 = (int)(SWIG_As_int(obj2));
30521 if (SWIG_arg_fail(3)) SWIG_fail;
30522 }
30523 {
30524 arg4 = (int)(SWIG_As_int(obj3));
30525 if (SWIG_arg_fail(4)) SWIG_fail;
30526 }
30527 {
30528 arg5 = (int)(SWIG_As_int(obj4));
30529 if (SWIG_arg_fail(5)) SWIG_fail;
30530 }
30531 if (obj5) {
30532 {
30533 arg6 = (bool)(SWIG_As_bool(obj5));
30534 if (SWIG_arg_fail(6)) SWIG_fail;
30535 }
30536 }
30537 {
30538 PyThreadState* __tstate = wxPyBeginAllowThreads();
30539 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30540
30541 wxPyEndAllowThreads(__tstate);
30542 if (PyErr_Occurred()) SWIG_fail;
30543 }
30544 Py_INCREF(Py_None); resultobj = Py_None;
30545 return resultobj;
30546 fail:
30547 return NULL;
30548 }
30549
30550
30551 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30552 PyObject *resultobj;
30553 wxWindow *arg1 = (wxWindow *) 0 ;
30554 int arg2 ;
30555 int arg3 ;
30556 bool arg4 = (bool) true ;
30557 PyObject * obj0 = 0 ;
30558 PyObject * obj1 = 0 ;
30559 PyObject * obj2 = 0 ;
30560 PyObject * obj3 = 0 ;
30561 char *kwnames[] = {
30562 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30563 };
30564
30565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30567 if (SWIG_arg_fail(1)) SWIG_fail;
30568 {
30569 arg2 = (int)(SWIG_As_int(obj1));
30570 if (SWIG_arg_fail(2)) SWIG_fail;
30571 }
30572 {
30573 arg3 = (int)(SWIG_As_int(obj2));
30574 if (SWIG_arg_fail(3)) SWIG_fail;
30575 }
30576 if (obj3) {
30577 {
30578 arg4 = (bool)(SWIG_As_bool(obj3));
30579 if (SWIG_arg_fail(4)) SWIG_fail;
30580 }
30581 }
30582 {
30583 PyThreadState* __tstate = wxPyBeginAllowThreads();
30584 (arg1)->SetScrollPos(arg2,arg3,arg4);
30585
30586 wxPyEndAllowThreads(__tstate);
30587 if (PyErr_Occurred()) SWIG_fail;
30588 }
30589 Py_INCREF(Py_None); resultobj = Py_None;
30590 return resultobj;
30591 fail:
30592 return NULL;
30593 }
30594
30595
30596 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30597 PyObject *resultobj;
30598 wxWindow *arg1 = (wxWindow *) 0 ;
30599 int arg2 ;
30600 int result;
30601 PyObject * obj0 = 0 ;
30602 PyObject * obj1 = 0 ;
30603 char *kwnames[] = {
30604 (char *) "self",(char *) "orientation", NULL
30605 };
30606
30607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30609 if (SWIG_arg_fail(1)) SWIG_fail;
30610 {
30611 arg2 = (int)(SWIG_As_int(obj1));
30612 if (SWIG_arg_fail(2)) SWIG_fail;
30613 }
30614 {
30615 PyThreadState* __tstate = wxPyBeginAllowThreads();
30616 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30617
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 {
30622 resultobj = SWIG_From_int((int)(result));
30623 }
30624 return resultobj;
30625 fail:
30626 return NULL;
30627 }
30628
30629
30630 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30631 PyObject *resultobj;
30632 wxWindow *arg1 = (wxWindow *) 0 ;
30633 int arg2 ;
30634 int result;
30635 PyObject * obj0 = 0 ;
30636 PyObject * obj1 = 0 ;
30637 char *kwnames[] = {
30638 (char *) "self",(char *) "orientation", NULL
30639 };
30640
30641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30643 if (SWIG_arg_fail(1)) SWIG_fail;
30644 {
30645 arg2 = (int)(SWIG_As_int(obj1));
30646 if (SWIG_arg_fail(2)) SWIG_fail;
30647 }
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30651
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 {
30656 resultobj = SWIG_From_int((int)(result));
30657 }
30658 return resultobj;
30659 fail:
30660 return NULL;
30661 }
30662
30663
30664 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30665 PyObject *resultobj;
30666 wxWindow *arg1 = (wxWindow *) 0 ;
30667 int arg2 ;
30668 int result;
30669 PyObject * obj0 = 0 ;
30670 PyObject * obj1 = 0 ;
30671 char *kwnames[] = {
30672 (char *) "self",(char *) "orientation", NULL
30673 };
30674
30675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30677 if (SWIG_arg_fail(1)) SWIG_fail;
30678 {
30679 arg2 = (int)(SWIG_As_int(obj1));
30680 if (SWIG_arg_fail(2)) SWIG_fail;
30681 }
30682 {
30683 PyThreadState* __tstate = wxPyBeginAllowThreads();
30684 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30685
30686 wxPyEndAllowThreads(__tstate);
30687 if (PyErr_Occurred()) SWIG_fail;
30688 }
30689 {
30690 resultobj = SWIG_From_int((int)(result));
30691 }
30692 return resultobj;
30693 fail:
30694 return NULL;
30695 }
30696
30697
30698 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30699 PyObject *resultobj;
30700 wxWindow *arg1 = (wxWindow *) 0 ;
30701 int arg2 ;
30702 int arg3 ;
30703 wxRect *arg4 = (wxRect *) NULL ;
30704 PyObject * obj0 = 0 ;
30705 PyObject * obj1 = 0 ;
30706 PyObject * obj2 = 0 ;
30707 PyObject * obj3 = 0 ;
30708 char *kwnames[] = {
30709 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30710 };
30711
30712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30714 if (SWIG_arg_fail(1)) SWIG_fail;
30715 {
30716 arg2 = (int)(SWIG_As_int(obj1));
30717 if (SWIG_arg_fail(2)) SWIG_fail;
30718 }
30719 {
30720 arg3 = (int)(SWIG_As_int(obj2));
30721 if (SWIG_arg_fail(3)) SWIG_fail;
30722 }
30723 if (obj3) {
30724 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30725 if (SWIG_arg_fail(4)) SWIG_fail;
30726 }
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30730
30731 wxPyEndAllowThreads(__tstate);
30732 if (PyErr_Occurred()) SWIG_fail;
30733 }
30734 Py_INCREF(Py_None); resultobj = Py_None;
30735 return resultobj;
30736 fail:
30737 return NULL;
30738 }
30739
30740
30741 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30742 PyObject *resultobj;
30743 wxWindow *arg1 = (wxWindow *) 0 ;
30744 int arg2 ;
30745 bool result;
30746 PyObject * obj0 = 0 ;
30747 PyObject * obj1 = 0 ;
30748 char *kwnames[] = {
30749 (char *) "self",(char *) "lines", NULL
30750 };
30751
30752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30754 if (SWIG_arg_fail(1)) SWIG_fail;
30755 {
30756 arg2 = (int)(SWIG_As_int(obj1));
30757 if (SWIG_arg_fail(2)) SWIG_fail;
30758 }
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = (bool)(arg1)->ScrollLines(arg2);
30762
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 {
30767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30768 }
30769 return resultobj;
30770 fail:
30771 return NULL;
30772 }
30773
30774
30775 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30776 PyObject *resultobj;
30777 wxWindow *arg1 = (wxWindow *) 0 ;
30778 int arg2 ;
30779 bool result;
30780 PyObject * obj0 = 0 ;
30781 PyObject * obj1 = 0 ;
30782 char *kwnames[] = {
30783 (char *) "self",(char *) "pages", NULL
30784 };
30785
30786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30788 if (SWIG_arg_fail(1)) SWIG_fail;
30789 {
30790 arg2 = (int)(SWIG_As_int(obj1));
30791 if (SWIG_arg_fail(2)) SWIG_fail;
30792 }
30793 {
30794 PyThreadState* __tstate = wxPyBeginAllowThreads();
30795 result = (bool)(arg1)->ScrollPages(arg2);
30796
30797 wxPyEndAllowThreads(__tstate);
30798 if (PyErr_Occurred()) SWIG_fail;
30799 }
30800 {
30801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30802 }
30803 return resultobj;
30804 fail:
30805 return NULL;
30806 }
30807
30808
30809 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30810 PyObject *resultobj;
30811 wxWindow *arg1 = (wxWindow *) 0 ;
30812 bool result;
30813 PyObject * obj0 = 0 ;
30814 char *kwnames[] = {
30815 (char *) "self", NULL
30816 };
30817
30818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30820 if (SWIG_arg_fail(1)) SWIG_fail;
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 result = (bool)(arg1)->LineUp();
30824
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 {
30829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30830 }
30831 return resultobj;
30832 fail:
30833 return NULL;
30834 }
30835
30836
30837 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30838 PyObject *resultobj;
30839 wxWindow *arg1 = (wxWindow *) 0 ;
30840 bool result;
30841 PyObject * obj0 = 0 ;
30842 char *kwnames[] = {
30843 (char *) "self", NULL
30844 };
30845
30846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30848 if (SWIG_arg_fail(1)) SWIG_fail;
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = (bool)(arg1)->LineDown();
30852
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 {
30857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30858 }
30859 return resultobj;
30860 fail:
30861 return NULL;
30862 }
30863
30864
30865 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30866 PyObject *resultobj;
30867 wxWindow *arg1 = (wxWindow *) 0 ;
30868 bool result;
30869 PyObject * obj0 = 0 ;
30870 char *kwnames[] = {
30871 (char *) "self", NULL
30872 };
30873
30874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30876 if (SWIG_arg_fail(1)) SWIG_fail;
30877 {
30878 PyThreadState* __tstate = wxPyBeginAllowThreads();
30879 result = (bool)(arg1)->PageUp();
30880
30881 wxPyEndAllowThreads(__tstate);
30882 if (PyErr_Occurred()) SWIG_fail;
30883 }
30884 {
30885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30886 }
30887 return resultobj;
30888 fail:
30889 return NULL;
30890 }
30891
30892
30893 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30894 PyObject *resultobj;
30895 wxWindow *arg1 = (wxWindow *) 0 ;
30896 bool result;
30897 PyObject * obj0 = 0 ;
30898 char *kwnames[] = {
30899 (char *) "self", NULL
30900 };
30901
30902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30904 if (SWIG_arg_fail(1)) SWIG_fail;
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 result = (bool)(arg1)->PageDown();
30908
30909 wxPyEndAllowThreads(__tstate);
30910 if (PyErr_Occurred()) SWIG_fail;
30911 }
30912 {
30913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30914 }
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30922 PyObject *resultobj;
30923 wxWindow *arg1 = (wxWindow *) 0 ;
30924 wxString *arg2 = 0 ;
30925 bool temp2 = false ;
30926 PyObject * obj0 = 0 ;
30927 PyObject * obj1 = 0 ;
30928 char *kwnames[] = {
30929 (char *) "self",(char *) "text", NULL
30930 };
30931
30932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30934 if (SWIG_arg_fail(1)) SWIG_fail;
30935 {
30936 arg2 = wxString_in_helper(obj1);
30937 if (arg2 == NULL) SWIG_fail;
30938 temp2 = true;
30939 }
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 (arg1)->SetHelpText((wxString const &)*arg2);
30943
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 Py_INCREF(Py_None); resultobj = Py_None;
30948 {
30949 if (temp2)
30950 delete arg2;
30951 }
30952 return resultobj;
30953 fail:
30954 {
30955 if (temp2)
30956 delete arg2;
30957 }
30958 return NULL;
30959 }
30960
30961
30962 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30963 PyObject *resultobj;
30964 wxWindow *arg1 = (wxWindow *) 0 ;
30965 wxString *arg2 = 0 ;
30966 bool temp2 = false ;
30967 PyObject * obj0 = 0 ;
30968 PyObject * obj1 = 0 ;
30969 char *kwnames[] = {
30970 (char *) "self",(char *) "text", NULL
30971 };
30972
30973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30975 if (SWIG_arg_fail(1)) SWIG_fail;
30976 {
30977 arg2 = wxString_in_helper(obj1);
30978 if (arg2 == NULL) SWIG_fail;
30979 temp2 = true;
30980 }
30981 {
30982 PyThreadState* __tstate = wxPyBeginAllowThreads();
30983 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30984
30985 wxPyEndAllowThreads(__tstate);
30986 if (PyErr_Occurred()) SWIG_fail;
30987 }
30988 Py_INCREF(Py_None); resultobj = Py_None;
30989 {
30990 if (temp2)
30991 delete arg2;
30992 }
30993 return resultobj;
30994 fail:
30995 {
30996 if (temp2)
30997 delete arg2;
30998 }
30999 return NULL;
31000 }
31001
31002
31003 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31004 PyObject *resultobj;
31005 wxWindow *arg1 = (wxWindow *) 0 ;
31006 wxString result;
31007 PyObject * obj0 = 0 ;
31008 char *kwnames[] = {
31009 (char *) "self", NULL
31010 };
31011
31012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31014 if (SWIG_arg_fail(1)) SWIG_fail;
31015 {
31016 PyThreadState* __tstate = wxPyBeginAllowThreads();
31017 result = ((wxWindow const *)arg1)->GetHelpText();
31018
31019 wxPyEndAllowThreads(__tstate);
31020 if (PyErr_Occurred()) SWIG_fail;
31021 }
31022 {
31023 #if wxUSE_UNICODE
31024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31025 #else
31026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31027 #endif
31028 }
31029 return resultobj;
31030 fail:
31031 return NULL;
31032 }
31033
31034
31035 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31036 PyObject *resultobj;
31037 wxWindow *arg1 = (wxWindow *) 0 ;
31038 wxString *arg2 = 0 ;
31039 bool temp2 = false ;
31040 PyObject * obj0 = 0 ;
31041 PyObject * obj1 = 0 ;
31042 char *kwnames[] = {
31043 (char *) "self",(char *) "tip", NULL
31044 };
31045
31046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31048 if (SWIG_arg_fail(1)) SWIG_fail;
31049 {
31050 arg2 = wxString_in_helper(obj1);
31051 if (arg2 == NULL) SWIG_fail;
31052 temp2 = true;
31053 }
31054 {
31055 PyThreadState* __tstate = wxPyBeginAllowThreads();
31056 (arg1)->SetToolTip((wxString const &)*arg2);
31057
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 Py_INCREF(Py_None); resultobj = Py_None;
31062 {
31063 if (temp2)
31064 delete arg2;
31065 }
31066 return resultobj;
31067 fail:
31068 {
31069 if (temp2)
31070 delete arg2;
31071 }
31072 return NULL;
31073 }
31074
31075
31076 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31077 PyObject *resultobj;
31078 wxWindow *arg1 = (wxWindow *) 0 ;
31079 wxToolTip *arg2 = (wxToolTip *) 0 ;
31080 PyObject * obj0 = 0 ;
31081 PyObject * obj1 = 0 ;
31082 char *kwnames[] = {
31083 (char *) "self",(char *) "tip", NULL
31084 };
31085
31086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31088 if (SWIG_arg_fail(1)) SWIG_fail;
31089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31090 if (SWIG_arg_fail(2)) SWIG_fail;
31091 {
31092 PyThreadState* __tstate = wxPyBeginAllowThreads();
31093 (arg1)->SetToolTip(arg2);
31094
31095 wxPyEndAllowThreads(__tstate);
31096 if (PyErr_Occurred()) SWIG_fail;
31097 }
31098 Py_INCREF(Py_None); resultobj = Py_None;
31099 return resultobj;
31100 fail:
31101 return NULL;
31102 }
31103
31104
31105 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31106 PyObject *resultobj;
31107 wxWindow *arg1 = (wxWindow *) 0 ;
31108 wxToolTip *result;
31109 PyObject * obj0 = 0 ;
31110 char *kwnames[] = {
31111 (char *) "self", NULL
31112 };
31113
31114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31116 if (SWIG_arg_fail(1)) SWIG_fail;
31117 {
31118 PyThreadState* __tstate = wxPyBeginAllowThreads();
31119 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31120
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 {
31125 resultobj = wxPyMake_wxObject(result, 0);
31126 }
31127 return resultobj;
31128 fail:
31129 return NULL;
31130 }
31131
31132
31133 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31134 PyObject *resultobj;
31135 wxWindow *arg1 = (wxWindow *) 0 ;
31136 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31137 PyObject * obj0 = 0 ;
31138 PyObject * obj1 = 0 ;
31139 char *kwnames[] = {
31140 (char *) "self",(char *) "dropTarget", NULL
31141 };
31142
31143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31145 if (SWIG_arg_fail(1)) SWIG_fail;
31146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31147 if (SWIG_arg_fail(2)) SWIG_fail;
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 (arg1)->SetDropTarget(arg2);
31151
31152 wxPyEndAllowThreads(__tstate);
31153 if (PyErr_Occurred()) SWIG_fail;
31154 }
31155 Py_INCREF(Py_None); resultobj = Py_None;
31156 return resultobj;
31157 fail:
31158 return NULL;
31159 }
31160
31161
31162 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31163 PyObject *resultobj;
31164 wxWindow *arg1 = (wxWindow *) 0 ;
31165 wxPyDropTarget *result;
31166 PyObject * obj0 = 0 ;
31167 char *kwnames[] = {
31168 (char *) "self", NULL
31169 };
31170
31171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31173 if (SWIG_arg_fail(1)) SWIG_fail;
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31177
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31182 return resultobj;
31183 fail:
31184 return NULL;
31185 }
31186
31187
31188 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31189 PyObject *resultobj;
31190 wxWindow *arg1 = (wxWindow *) 0 ;
31191 bool arg2 ;
31192 PyObject * obj0 = 0 ;
31193 PyObject * obj1 = 0 ;
31194 char *kwnames[] = {
31195 (char *) "self",(char *) "accept", NULL
31196 };
31197
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31200 if (SWIG_arg_fail(1)) SWIG_fail;
31201 {
31202 arg2 = (bool)(SWIG_As_bool(obj1));
31203 if (SWIG_arg_fail(2)) SWIG_fail;
31204 }
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 (arg1)->DragAcceptFiles(arg2);
31208
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 Py_INCREF(Py_None); resultobj = Py_None;
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31223 PyObject * obj0 = 0 ;
31224 PyObject * obj1 = 0 ;
31225 char *kwnames[] = {
31226 (char *) "self",(char *) "constraints", NULL
31227 };
31228
31229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31231 if (SWIG_arg_fail(1)) SWIG_fail;
31232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31233 if (SWIG_arg_fail(2)) SWIG_fail;
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 (arg1)->SetConstraints(arg2);
31237
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 Py_INCREF(Py_None); resultobj = Py_None;
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj;
31250 wxWindow *arg1 = (wxWindow *) 0 ;
31251 wxLayoutConstraints *result;
31252 PyObject * obj0 = 0 ;
31253 char *kwnames[] = {
31254 (char *) "self", NULL
31255 };
31256
31257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31259 if (SWIG_arg_fail(1)) SWIG_fail;
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31263
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31275 PyObject *resultobj;
31276 wxWindow *arg1 = (wxWindow *) 0 ;
31277 bool arg2 ;
31278 PyObject * obj0 = 0 ;
31279 PyObject * obj1 = 0 ;
31280 char *kwnames[] = {
31281 (char *) "self",(char *) "autoLayout", NULL
31282 };
31283
31284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31286 if (SWIG_arg_fail(1)) SWIG_fail;
31287 {
31288 arg2 = (bool)(SWIG_As_bool(obj1));
31289 if (SWIG_arg_fail(2)) SWIG_fail;
31290 }
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 (arg1)->SetAutoLayout(arg2);
31294
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 Py_INCREF(Py_None); resultobj = Py_None;
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj;
31307 wxWindow *arg1 = (wxWindow *) 0 ;
31308 bool result;
31309 PyObject * obj0 = 0 ;
31310 char *kwnames[] = {
31311 (char *) "self", NULL
31312 };
31313
31314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31316 if (SWIG_arg_fail(1)) SWIG_fail;
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31320
31321 wxPyEndAllowThreads(__tstate);
31322 if (PyErr_Occurred()) SWIG_fail;
31323 }
31324 {
31325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31326 }
31327 return resultobj;
31328 fail:
31329 return NULL;
31330 }
31331
31332
31333 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31334 PyObject *resultobj;
31335 wxWindow *arg1 = (wxWindow *) 0 ;
31336 bool result;
31337 PyObject * obj0 = 0 ;
31338 char *kwnames[] = {
31339 (char *) "self", NULL
31340 };
31341
31342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31344 if (SWIG_arg_fail(1)) SWIG_fail;
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 result = (bool)(arg1)->Layout();
31348
31349 wxPyEndAllowThreads(__tstate);
31350 if (PyErr_Occurred()) SWIG_fail;
31351 }
31352 {
31353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31354 }
31355 return resultobj;
31356 fail:
31357 return NULL;
31358 }
31359
31360
31361 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj;
31363 wxWindow *arg1 = (wxWindow *) 0 ;
31364 wxSizer *arg2 = (wxSizer *) 0 ;
31365 bool arg3 = (bool) true ;
31366 PyObject * obj0 = 0 ;
31367 PyObject * obj1 = 0 ;
31368 PyObject * obj2 = 0 ;
31369 char *kwnames[] = {
31370 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31371 };
31372
31373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31375 if (SWIG_arg_fail(1)) SWIG_fail;
31376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31377 if (SWIG_arg_fail(2)) SWIG_fail;
31378 if (obj2) {
31379 {
31380 arg3 = (bool)(SWIG_As_bool(obj2));
31381 if (SWIG_arg_fail(3)) SWIG_fail;
31382 }
31383 }
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 (arg1)->SetSizer(arg2,arg3);
31387
31388 wxPyEndAllowThreads(__tstate);
31389 if (PyErr_Occurred()) SWIG_fail;
31390 }
31391 Py_INCREF(Py_None); resultobj = Py_None;
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj;
31400 wxWindow *arg1 = (wxWindow *) 0 ;
31401 wxSizer *arg2 = (wxSizer *) 0 ;
31402 bool arg3 = (bool) true ;
31403 PyObject * obj0 = 0 ;
31404 PyObject * obj1 = 0 ;
31405 PyObject * obj2 = 0 ;
31406 char *kwnames[] = {
31407 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31408 };
31409
31410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31412 if (SWIG_arg_fail(1)) SWIG_fail;
31413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31414 if (SWIG_arg_fail(2)) SWIG_fail;
31415 if (obj2) {
31416 {
31417 arg3 = (bool)(SWIG_As_bool(obj2));
31418 if (SWIG_arg_fail(3)) SWIG_fail;
31419 }
31420 }
31421 {
31422 PyThreadState* __tstate = wxPyBeginAllowThreads();
31423 (arg1)->SetSizerAndFit(arg2,arg3);
31424
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 Py_INCREF(Py_None); resultobj = Py_None;
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31436 PyObject *resultobj;
31437 wxWindow *arg1 = (wxWindow *) 0 ;
31438 wxSizer *result;
31439 PyObject * obj0 = 0 ;
31440 char *kwnames[] = {
31441 (char *) "self", NULL
31442 };
31443
31444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31446 if (SWIG_arg_fail(1)) SWIG_fail;
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31450
31451 wxPyEndAllowThreads(__tstate);
31452 if (PyErr_Occurred()) SWIG_fail;
31453 }
31454 {
31455 resultobj = wxPyMake_wxSizer(result, 0);
31456 }
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31464 PyObject *resultobj;
31465 wxWindow *arg1 = (wxWindow *) 0 ;
31466 wxSizer *arg2 = (wxSizer *) 0 ;
31467 PyObject * obj0 = 0 ;
31468 PyObject * obj1 = 0 ;
31469 char *kwnames[] = {
31470 (char *) "self",(char *) "sizer", NULL
31471 };
31472
31473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31475 if (SWIG_arg_fail(1)) SWIG_fail;
31476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31477 if (SWIG_arg_fail(2)) SWIG_fail;
31478 {
31479 PyThreadState* __tstate = wxPyBeginAllowThreads();
31480 (arg1)->SetContainingSizer(arg2);
31481
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 Py_INCREF(Py_None); resultobj = Py_None;
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31493 PyObject *resultobj;
31494 wxWindow *arg1 = (wxWindow *) 0 ;
31495 wxSizer *result;
31496 PyObject * obj0 = 0 ;
31497 char *kwnames[] = {
31498 (char *) "self", NULL
31499 };
31500
31501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31503 if (SWIG_arg_fail(1)) SWIG_fail;
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31507
31508 wxPyEndAllowThreads(__tstate);
31509 if (PyErr_Occurred()) SWIG_fail;
31510 }
31511 {
31512 resultobj = wxPyMake_wxSizer(result, 0);
31513 }
31514 return resultobj;
31515 fail:
31516 return NULL;
31517 }
31518
31519
31520 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31521 PyObject *resultobj;
31522 wxWindow *arg1 = (wxWindow *) 0 ;
31523 PyObject * obj0 = 0 ;
31524 char *kwnames[] = {
31525 (char *) "self", NULL
31526 };
31527
31528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31530 if (SWIG_arg_fail(1)) SWIG_fail;
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 (arg1)->InheritAttributes();
31534
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 Py_INCREF(Py_None); resultobj = Py_None;
31539 return resultobj;
31540 fail:
31541 return NULL;
31542 }
31543
31544
31545 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31546 PyObject *resultobj;
31547 wxWindow *arg1 = (wxWindow *) 0 ;
31548 bool result;
31549 PyObject * obj0 = 0 ;
31550 char *kwnames[] = {
31551 (char *) "self", NULL
31552 };
31553
31554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31556 if (SWIG_arg_fail(1)) SWIG_fail;
31557 {
31558 PyThreadState* __tstate = wxPyBeginAllowThreads();
31559 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31560
31561 wxPyEndAllowThreads(__tstate);
31562 if (PyErr_Occurred()) SWIG_fail;
31563 }
31564 {
31565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31566 }
31567 return resultobj;
31568 fail:
31569 return NULL;
31570 }
31571
31572
31573 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31574 PyObject *obj;
31575 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31576 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31577 Py_INCREF(obj);
31578 return Py_BuildValue((char *)"");
31579 }
31580 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31581 PyObject *resultobj;
31582 long arg1 ;
31583 wxWindow *arg2 = (wxWindow *) NULL ;
31584 wxWindow *result;
31585 PyObject * obj0 = 0 ;
31586 PyObject * obj1 = 0 ;
31587 char *kwnames[] = {
31588 (char *) "id",(char *) "parent", NULL
31589 };
31590
31591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31592 {
31593 arg1 = (long)(SWIG_As_long(obj0));
31594 if (SWIG_arg_fail(1)) SWIG_fail;
31595 }
31596 if (obj1) {
31597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31598 if (SWIG_arg_fail(2)) SWIG_fail;
31599 }
31600 {
31601 if (!wxPyCheckForApp()) SWIG_fail;
31602 PyThreadState* __tstate = wxPyBeginAllowThreads();
31603 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31604
31605 wxPyEndAllowThreads(__tstate);
31606 if (PyErr_Occurred()) SWIG_fail;
31607 }
31608 {
31609 resultobj = wxPyMake_wxObject(result, 0);
31610 }
31611 return resultobj;
31612 fail:
31613 return NULL;
31614 }
31615
31616
31617 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31618 PyObject *resultobj;
31619 wxString *arg1 = 0 ;
31620 wxWindow *arg2 = (wxWindow *) NULL ;
31621 wxWindow *result;
31622 bool temp1 = false ;
31623 PyObject * obj0 = 0 ;
31624 PyObject * obj1 = 0 ;
31625 char *kwnames[] = {
31626 (char *) "name",(char *) "parent", NULL
31627 };
31628
31629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31630 {
31631 arg1 = wxString_in_helper(obj0);
31632 if (arg1 == NULL) SWIG_fail;
31633 temp1 = true;
31634 }
31635 if (obj1) {
31636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31637 if (SWIG_arg_fail(2)) SWIG_fail;
31638 }
31639 {
31640 if (!wxPyCheckForApp()) SWIG_fail;
31641 PyThreadState* __tstate = wxPyBeginAllowThreads();
31642 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31643
31644 wxPyEndAllowThreads(__tstate);
31645 if (PyErr_Occurred()) SWIG_fail;
31646 }
31647 {
31648 resultobj = wxPyMake_wxObject(result, 0);
31649 }
31650 {
31651 if (temp1)
31652 delete arg1;
31653 }
31654 return resultobj;
31655 fail:
31656 {
31657 if (temp1)
31658 delete arg1;
31659 }
31660 return NULL;
31661 }
31662
31663
31664 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31665 PyObject *resultobj;
31666 wxString *arg1 = 0 ;
31667 wxWindow *arg2 = (wxWindow *) NULL ;
31668 wxWindow *result;
31669 bool temp1 = false ;
31670 PyObject * obj0 = 0 ;
31671 PyObject * obj1 = 0 ;
31672 char *kwnames[] = {
31673 (char *) "label",(char *) "parent", NULL
31674 };
31675
31676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31677 {
31678 arg1 = wxString_in_helper(obj0);
31679 if (arg1 == NULL) SWIG_fail;
31680 temp1 = true;
31681 }
31682 if (obj1) {
31683 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31684 if (SWIG_arg_fail(2)) SWIG_fail;
31685 }
31686 {
31687 if (!wxPyCheckForApp()) SWIG_fail;
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31690
31691 wxPyEndAllowThreads(__tstate);
31692 if (PyErr_Occurred()) SWIG_fail;
31693 }
31694 {
31695 resultobj = wxPyMake_wxObject(result, 0);
31696 }
31697 {
31698 if (temp1)
31699 delete arg1;
31700 }
31701 return resultobj;
31702 fail:
31703 {
31704 if (temp1)
31705 delete arg1;
31706 }
31707 return NULL;
31708 }
31709
31710
31711 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31712 PyObject *resultobj;
31713 wxWindow *arg1 = (wxWindow *) 0 ;
31714 unsigned long arg2 ;
31715 wxWindow *result;
31716 PyObject * obj0 = 0 ;
31717 PyObject * obj1 = 0 ;
31718 char *kwnames[] = {
31719 (char *) "parent",(char *) "_hWnd", NULL
31720 };
31721
31722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31724 if (SWIG_arg_fail(1)) SWIG_fail;
31725 {
31726 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31727 if (SWIG_arg_fail(2)) SWIG_fail;
31728 }
31729 {
31730 PyThreadState* __tstate = wxPyBeginAllowThreads();
31731 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31732
31733 wxPyEndAllowThreads(__tstate);
31734 if (PyErr_Occurred()) SWIG_fail;
31735 }
31736 {
31737 resultobj = wxPyMake_wxObject(result, 0);
31738 }
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj;
31747 wxValidator *result;
31748 char *kwnames[] = {
31749 NULL
31750 };
31751
31752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31753 {
31754 PyThreadState* __tstate = wxPyBeginAllowThreads();
31755 result = (wxValidator *)new wxValidator();
31756
31757 wxPyEndAllowThreads(__tstate);
31758 if (PyErr_Occurred()) SWIG_fail;
31759 }
31760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31761 return resultobj;
31762 fail:
31763 return NULL;
31764 }
31765
31766
31767 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31768 PyObject *resultobj;
31769 wxValidator *arg1 = (wxValidator *) 0 ;
31770 wxValidator *result;
31771 PyObject * obj0 = 0 ;
31772 char *kwnames[] = {
31773 (char *) "self", NULL
31774 };
31775
31776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31778 if (SWIG_arg_fail(1)) SWIG_fail;
31779 {
31780 PyThreadState* __tstate = wxPyBeginAllowThreads();
31781 result = (wxValidator *)(arg1)->Clone();
31782
31783 wxPyEndAllowThreads(__tstate);
31784 if (PyErr_Occurred()) SWIG_fail;
31785 }
31786 {
31787 resultobj = wxPyMake_wxObject(result, 0);
31788 }
31789 return resultobj;
31790 fail:
31791 return NULL;
31792 }
31793
31794
31795 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31796 PyObject *resultobj;
31797 wxValidator *arg1 = (wxValidator *) 0 ;
31798 wxWindow *arg2 = (wxWindow *) 0 ;
31799 bool result;
31800 PyObject * obj0 = 0 ;
31801 PyObject * obj1 = 0 ;
31802 char *kwnames[] = {
31803 (char *) "self",(char *) "parent", NULL
31804 };
31805
31806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31808 if (SWIG_arg_fail(1)) SWIG_fail;
31809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31810 if (SWIG_arg_fail(2)) SWIG_fail;
31811 {
31812 PyThreadState* __tstate = wxPyBeginAllowThreads();
31813 result = (bool)(arg1)->Validate(arg2);
31814
31815 wxPyEndAllowThreads(__tstate);
31816 if (PyErr_Occurred()) SWIG_fail;
31817 }
31818 {
31819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31820 }
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31828 PyObject *resultobj;
31829 wxValidator *arg1 = (wxValidator *) 0 ;
31830 bool result;
31831 PyObject * obj0 = 0 ;
31832 char *kwnames[] = {
31833 (char *) "self", NULL
31834 };
31835
31836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31838 if (SWIG_arg_fail(1)) SWIG_fail;
31839 {
31840 PyThreadState* __tstate = wxPyBeginAllowThreads();
31841 result = (bool)(arg1)->TransferToWindow();
31842
31843 wxPyEndAllowThreads(__tstate);
31844 if (PyErr_Occurred()) SWIG_fail;
31845 }
31846 {
31847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31848 }
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31856 PyObject *resultobj;
31857 wxValidator *arg1 = (wxValidator *) 0 ;
31858 bool result;
31859 PyObject * obj0 = 0 ;
31860 char *kwnames[] = {
31861 (char *) "self", NULL
31862 };
31863
31864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31866 if (SWIG_arg_fail(1)) SWIG_fail;
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = (bool)(arg1)->TransferFromWindow();
31870
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 {
31875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31876 }
31877 return resultobj;
31878 fail:
31879 return NULL;
31880 }
31881
31882
31883 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31884 PyObject *resultobj;
31885 wxValidator *arg1 = (wxValidator *) 0 ;
31886 wxWindow *result;
31887 PyObject * obj0 = 0 ;
31888 char *kwnames[] = {
31889 (char *) "self", NULL
31890 };
31891
31892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31894 if (SWIG_arg_fail(1)) SWIG_fail;
31895 {
31896 PyThreadState* __tstate = wxPyBeginAllowThreads();
31897 result = (wxWindow *)(arg1)->GetWindow();
31898
31899 wxPyEndAllowThreads(__tstate);
31900 if (PyErr_Occurred()) SWIG_fail;
31901 }
31902 {
31903 resultobj = wxPyMake_wxObject(result, 0);
31904 }
31905 return resultobj;
31906 fail:
31907 return NULL;
31908 }
31909
31910
31911 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31912 PyObject *resultobj;
31913 wxValidator *arg1 = (wxValidator *) 0 ;
31914 wxWindow *arg2 = (wxWindow *) 0 ;
31915 PyObject * obj0 = 0 ;
31916 PyObject * obj1 = 0 ;
31917 char *kwnames[] = {
31918 (char *) "self",(char *) "window", NULL
31919 };
31920
31921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31923 if (SWIG_arg_fail(1)) SWIG_fail;
31924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31925 if (SWIG_arg_fail(2)) SWIG_fail;
31926 {
31927 PyThreadState* __tstate = wxPyBeginAllowThreads();
31928 (arg1)->SetWindow(arg2);
31929
31930 wxPyEndAllowThreads(__tstate);
31931 if (PyErr_Occurred()) SWIG_fail;
31932 }
31933 Py_INCREF(Py_None); resultobj = Py_None;
31934 return resultobj;
31935 fail:
31936 return NULL;
31937 }
31938
31939
31940 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31941 PyObject *resultobj;
31942 bool result;
31943 char *kwnames[] = {
31944 NULL
31945 };
31946
31947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31948 {
31949 PyThreadState* __tstate = wxPyBeginAllowThreads();
31950 result = (bool)wxValidator::IsSilent();
31951
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 {
31956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31957 }
31958 return resultobj;
31959 fail:
31960 return NULL;
31961 }
31962
31963
31964 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31965 PyObject *resultobj;
31966 int arg1 = (int) true ;
31967 PyObject * obj0 = 0 ;
31968 char *kwnames[] = {
31969 (char *) "doIt", NULL
31970 };
31971
31972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31973 if (obj0) {
31974 {
31975 arg1 = (int)(SWIG_As_int(obj0));
31976 if (SWIG_arg_fail(1)) SWIG_fail;
31977 }
31978 }
31979 {
31980 PyThreadState* __tstate = wxPyBeginAllowThreads();
31981 wxValidator::SetBellOnError(arg1);
31982
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 Py_INCREF(Py_None); resultobj = Py_None;
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31994 PyObject *obj;
31995 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31996 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31997 Py_INCREF(obj);
31998 return Py_BuildValue((char *)"");
31999 }
32000 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32001 PyObject *resultobj;
32002 wxPyValidator *result;
32003 char *kwnames[] = {
32004 NULL
32005 };
32006
32007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32008 {
32009 PyThreadState* __tstate = wxPyBeginAllowThreads();
32010 result = (wxPyValidator *)new wxPyValidator();
32011
32012 wxPyEndAllowThreads(__tstate);
32013 if (PyErr_Occurred()) SWIG_fail;
32014 }
32015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32023 PyObject *resultobj;
32024 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32025 PyObject *arg2 = (PyObject *) 0 ;
32026 PyObject *arg3 = (PyObject *) 0 ;
32027 int arg4 = (int) true ;
32028 PyObject * obj0 = 0 ;
32029 PyObject * obj1 = 0 ;
32030 PyObject * obj2 = 0 ;
32031 PyObject * obj3 = 0 ;
32032 char *kwnames[] = {
32033 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32034 };
32035
32036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32038 if (SWIG_arg_fail(1)) SWIG_fail;
32039 arg2 = obj1;
32040 arg3 = obj2;
32041 if (obj3) {
32042 {
32043 arg4 = (int)(SWIG_As_int(obj3));
32044 if (SWIG_arg_fail(4)) SWIG_fail;
32045 }
32046 }
32047 {
32048 PyThreadState* __tstate = wxPyBeginAllowThreads();
32049 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32050
32051 wxPyEndAllowThreads(__tstate);
32052 if (PyErr_Occurred()) SWIG_fail;
32053 }
32054 Py_INCREF(Py_None); resultobj = Py_None;
32055 return resultobj;
32056 fail:
32057 return NULL;
32058 }
32059
32060
32061 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32062 PyObject *obj;
32063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32064 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32065 Py_INCREF(obj);
32066 return Py_BuildValue((char *)"");
32067 }
32068 static int _wrap_DefaultValidator_set(PyObject *) {
32069 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32070 return 1;
32071 }
32072
32073
32074 static PyObject *_wrap_DefaultValidator_get(void) {
32075 PyObject *pyobj;
32076
32077 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32078 return pyobj;
32079 }
32080
32081
32082 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32083 PyObject *resultobj;
32084 wxString const &arg1_defvalue = wxPyEmptyString ;
32085 wxString *arg1 = (wxString *) &arg1_defvalue ;
32086 long arg2 = (long) 0 ;
32087 wxMenu *result;
32088 bool temp1 = false ;
32089 PyObject * obj0 = 0 ;
32090 PyObject * obj1 = 0 ;
32091 char *kwnames[] = {
32092 (char *) "title",(char *) "style", NULL
32093 };
32094
32095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32096 if (obj0) {
32097 {
32098 arg1 = wxString_in_helper(obj0);
32099 if (arg1 == NULL) SWIG_fail;
32100 temp1 = true;
32101 }
32102 }
32103 if (obj1) {
32104 {
32105 arg2 = (long)(SWIG_As_long(obj1));
32106 if (SWIG_arg_fail(2)) SWIG_fail;
32107 }
32108 }
32109 {
32110 if (!wxPyCheckForApp()) SWIG_fail;
32111 PyThreadState* __tstate = wxPyBeginAllowThreads();
32112 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32113
32114 wxPyEndAllowThreads(__tstate);
32115 if (PyErr_Occurred()) SWIG_fail;
32116 }
32117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32118 {
32119 if (temp1)
32120 delete arg1;
32121 }
32122 return resultobj;
32123 fail:
32124 {
32125 if (temp1)
32126 delete arg1;
32127 }
32128 return NULL;
32129 }
32130
32131
32132 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32133 PyObject *resultobj;
32134 wxMenu *arg1 = (wxMenu *) 0 ;
32135 int arg2 ;
32136 wxString *arg3 = 0 ;
32137 wxString const &arg4_defvalue = wxPyEmptyString ;
32138 wxString *arg4 = (wxString *) &arg4_defvalue ;
32139 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32140 wxMenuItem *result;
32141 bool temp3 = false ;
32142 bool temp4 = false ;
32143 PyObject * obj0 = 0 ;
32144 PyObject * obj1 = 0 ;
32145 PyObject * obj2 = 0 ;
32146 PyObject * obj3 = 0 ;
32147 PyObject * obj4 = 0 ;
32148 char *kwnames[] = {
32149 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32150 };
32151
32152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32154 if (SWIG_arg_fail(1)) SWIG_fail;
32155 {
32156 arg2 = (int)(SWIG_As_int(obj1));
32157 if (SWIG_arg_fail(2)) SWIG_fail;
32158 }
32159 {
32160 arg3 = wxString_in_helper(obj2);
32161 if (arg3 == NULL) SWIG_fail;
32162 temp3 = true;
32163 }
32164 if (obj3) {
32165 {
32166 arg4 = wxString_in_helper(obj3);
32167 if (arg4 == NULL) SWIG_fail;
32168 temp4 = true;
32169 }
32170 }
32171 if (obj4) {
32172 {
32173 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32174 if (SWIG_arg_fail(5)) SWIG_fail;
32175 }
32176 }
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32180
32181 wxPyEndAllowThreads(__tstate);
32182 if (PyErr_Occurred()) SWIG_fail;
32183 }
32184 {
32185 resultobj = wxPyMake_wxObject(result, 0);
32186 }
32187 {
32188 if (temp3)
32189 delete arg3;
32190 }
32191 {
32192 if (temp4)
32193 delete arg4;
32194 }
32195 return resultobj;
32196 fail:
32197 {
32198 if (temp3)
32199 delete arg3;
32200 }
32201 {
32202 if (temp4)
32203 delete arg4;
32204 }
32205 return NULL;
32206 }
32207
32208
32209 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32210 PyObject *resultobj;
32211 wxMenu *arg1 = (wxMenu *) 0 ;
32212 wxMenuItem *result;
32213 PyObject * obj0 = 0 ;
32214 char *kwnames[] = {
32215 (char *) "self", NULL
32216 };
32217
32218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32220 if (SWIG_arg_fail(1)) SWIG_fail;
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 result = (wxMenuItem *)(arg1)->AppendSeparator();
32224
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 {
32229 resultobj = wxPyMake_wxObject(result, 0);
32230 }
32231 return resultobj;
32232 fail:
32233 return NULL;
32234 }
32235
32236
32237 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32238 PyObject *resultobj;
32239 wxMenu *arg1 = (wxMenu *) 0 ;
32240 int arg2 ;
32241 wxString *arg3 = 0 ;
32242 wxString const &arg4_defvalue = wxPyEmptyString ;
32243 wxString *arg4 = (wxString *) &arg4_defvalue ;
32244 wxMenuItem *result;
32245 bool temp3 = false ;
32246 bool temp4 = false ;
32247 PyObject * obj0 = 0 ;
32248 PyObject * obj1 = 0 ;
32249 PyObject * obj2 = 0 ;
32250 PyObject * obj3 = 0 ;
32251 char *kwnames[] = {
32252 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32253 };
32254
32255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32257 if (SWIG_arg_fail(1)) SWIG_fail;
32258 {
32259 arg2 = (int)(SWIG_As_int(obj1));
32260 if (SWIG_arg_fail(2)) SWIG_fail;
32261 }
32262 {
32263 arg3 = wxString_in_helper(obj2);
32264 if (arg3 == NULL) SWIG_fail;
32265 temp3 = true;
32266 }
32267 if (obj3) {
32268 {
32269 arg4 = wxString_in_helper(obj3);
32270 if (arg4 == NULL) SWIG_fail;
32271 temp4 = true;
32272 }
32273 }
32274 {
32275 PyThreadState* __tstate = wxPyBeginAllowThreads();
32276 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32277
32278 wxPyEndAllowThreads(__tstate);
32279 if (PyErr_Occurred()) SWIG_fail;
32280 }
32281 {
32282 resultobj = wxPyMake_wxObject(result, 0);
32283 }
32284 {
32285 if (temp3)
32286 delete arg3;
32287 }
32288 {
32289 if (temp4)
32290 delete arg4;
32291 }
32292 return resultobj;
32293 fail:
32294 {
32295 if (temp3)
32296 delete arg3;
32297 }
32298 {
32299 if (temp4)
32300 delete arg4;
32301 }
32302 return NULL;
32303 }
32304
32305
32306 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32307 PyObject *resultobj;
32308 wxMenu *arg1 = (wxMenu *) 0 ;
32309 int arg2 ;
32310 wxString *arg3 = 0 ;
32311 wxString const &arg4_defvalue = wxPyEmptyString ;
32312 wxString *arg4 = (wxString *) &arg4_defvalue ;
32313 wxMenuItem *result;
32314 bool temp3 = false ;
32315 bool temp4 = false ;
32316 PyObject * obj0 = 0 ;
32317 PyObject * obj1 = 0 ;
32318 PyObject * obj2 = 0 ;
32319 PyObject * obj3 = 0 ;
32320 char *kwnames[] = {
32321 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32322 };
32323
32324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32326 if (SWIG_arg_fail(1)) SWIG_fail;
32327 {
32328 arg2 = (int)(SWIG_As_int(obj1));
32329 if (SWIG_arg_fail(2)) SWIG_fail;
32330 }
32331 {
32332 arg3 = wxString_in_helper(obj2);
32333 if (arg3 == NULL) SWIG_fail;
32334 temp3 = true;
32335 }
32336 if (obj3) {
32337 {
32338 arg4 = wxString_in_helper(obj3);
32339 if (arg4 == NULL) SWIG_fail;
32340 temp4 = true;
32341 }
32342 }
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32346
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 {
32351 resultobj = wxPyMake_wxObject(result, 0);
32352 }
32353 {
32354 if (temp3)
32355 delete arg3;
32356 }
32357 {
32358 if (temp4)
32359 delete arg4;
32360 }
32361 return resultobj;
32362 fail:
32363 {
32364 if (temp3)
32365 delete arg3;
32366 }
32367 {
32368 if (temp4)
32369 delete arg4;
32370 }
32371 return NULL;
32372 }
32373
32374
32375 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32376 PyObject *resultobj;
32377 wxMenu *arg1 = (wxMenu *) 0 ;
32378 int arg2 ;
32379 wxString *arg3 = 0 ;
32380 wxMenu *arg4 = (wxMenu *) 0 ;
32381 wxString const &arg5_defvalue = wxPyEmptyString ;
32382 wxString *arg5 = (wxString *) &arg5_defvalue ;
32383 wxMenuItem *result;
32384 bool temp3 = false ;
32385 bool temp5 = false ;
32386 PyObject * obj0 = 0 ;
32387 PyObject * obj1 = 0 ;
32388 PyObject * obj2 = 0 ;
32389 PyObject * obj3 = 0 ;
32390 PyObject * obj4 = 0 ;
32391 char *kwnames[] = {
32392 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32393 };
32394
32395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32397 if (SWIG_arg_fail(1)) SWIG_fail;
32398 {
32399 arg2 = (int)(SWIG_As_int(obj1));
32400 if (SWIG_arg_fail(2)) SWIG_fail;
32401 }
32402 {
32403 arg3 = wxString_in_helper(obj2);
32404 if (arg3 == NULL) SWIG_fail;
32405 temp3 = true;
32406 }
32407 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32408 if (SWIG_arg_fail(4)) SWIG_fail;
32409 if (obj4) {
32410 {
32411 arg5 = wxString_in_helper(obj4);
32412 if (arg5 == NULL) SWIG_fail;
32413 temp5 = true;
32414 }
32415 }
32416 {
32417 PyThreadState* __tstate = wxPyBeginAllowThreads();
32418 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32419
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 {
32424 resultobj = wxPyMake_wxObject(result, 0);
32425 }
32426 {
32427 if (temp3)
32428 delete arg3;
32429 }
32430 {
32431 if (temp5)
32432 delete arg5;
32433 }
32434 return resultobj;
32435 fail:
32436 {
32437 if (temp3)
32438 delete arg3;
32439 }
32440 {
32441 if (temp5)
32442 delete arg5;
32443 }
32444 return NULL;
32445 }
32446
32447
32448 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32449 PyObject *resultobj;
32450 wxMenu *arg1 = (wxMenu *) 0 ;
32451 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32452 wxMenuItem *result;
32453 PyObject * obj0 = 0 ;
32454 PyObject * obj1 = 0 ;
32455 char *kwnames[] = {
32456 (char *) "self",(char *) "item", NULL
32457 };
32458
32459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32461 if (SWIG_arg_fail(1)) SWIG_fail;
32462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32463 if (SWIG_arg_fail(2)) SWIG_fail;
32464 {
32465 PyThreadState* __tstate = wxPyBeginAllowThreads();
32466 result = (wxMenuItem *)(arg1)->Append(arg2);
32467
32468 wxPyEndAllowThreads(__tstate);
32469 if (PyErr_Occurred()) SWIG_fail;
32470 }
32471 {
32472 resultobj = wxPyMake_wxObject(result, 0);
32473 }
32474 return resultobj;
32475 fail:
32476 return NULL;
32477 }
32478
32479
32480 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32481 PyObject *resultobj;
32482 wxMenu *arg1 = (wxMenu *) 0 ;
32483 PyObject * obj0 = 0 ;
32484 char *kwnames[] = {
32485 (char *) "self", NULL
32486 };
32487
32488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32490 if (SWIG_arg_fail(1)) SWIG_fail;
32491 {
32492 PyThreadState* __tstate = wxPyBeginAllowThreads();
32493 (arg1)->Break();
32494
32495 wxPyEndAllowThreads(__tstate);
32496 if (PyErr_Occurred()) SWIG_fail;
32497 }
32498 Py_INCREF(Py_None); resultobj = Py_None;
32499 return resultobj;
32500 fail:
32501 return NULL;
32502 }
32503
32504
32505 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32506 PyObject *resultobj;
32507 wxMenu *arg1 = (wxMenu *) 0 ;
32508 size_t arg2 ;
32509 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32510 wxMenuItem *result;
32511 PyObject * obj0 = 0 ;
32512 PyObject * obj1 = 0 ;
32513 PyObject * obj2 = 0 ;
32514 char *kwnames[] = {
32515 (char *) "self",(char *) "pos",(char *) "item", NULL
32516 };
32517
32518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32520 if (SWIG_arg_fail(1)) SWIG_fail;
32521 {
32522 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32523 if (SWIG_arg_fail(2)) SWIG_fail;
32524 }
32525 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32526 if (SWIG_arg_fail(3)) SWIG_fail;
32527 {
32528 PyThreadState* __tstate = wxPyBeginAllowThreads();
32529 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32530
32531 wxPyEndAllowThreads(__tstate);
32532 if (PyErr_Occurred()) SWIG_fail;
32533 }
32534 {
32535 resultobj = wxPyMake_wxObject(result, 0);
32536 }
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32544 PyObject *resultobj;
32545 wxMenu *arg1 = (wxMenu *) 0 ;
32546 size_t arg2 ;
32547 int arg3 ;
32548 wxString *arg4 = 0 ;
32549 wxString const &arg5_defvalue = wxPyEmptyString ;
32550 wxString *arg5 = (wxString *) &arg5_defvalue ;
32551 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32552 wxMenuItem *result;
32553 bool temp4 = false ;
32554 bool temp5 = false ;
32555 PyObject * obj0 = 0 ;
32556 PyObject * obj1 = 0 ;
32557 PyObject * obj2 = 0 ;
32558 PyObject * obj3 = 0 ;
32559 PyObject * obj4 = 0 ;
32560 PyObject * obj5 = 0 ;
32561 char *kwnames[] = {
32562 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32563 };
32564
32565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32567 if (SWIG_arg_fail(1)) SWIG_fail;
32568 {
32569 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32570 if (SWIG_arg_fail(2)) SWIG_fail;
32571 }
32572 {
32573 arg3 = (int)(SWIG_As_int(obj2));
32574 if (SWIG_arg_fail(3)) SWIG_fail;
32575 }
32576 {
32577 arg4 = wxString_in_helper(obj3);
32578 if (arg4 == NULL) SWIG_fail;
32579 temp4 = true;
32580 }
32581 if (obj4) {
32582 {
32583 arg5 = wxString_in_helper(obj4);
32584 if (arg5 == NULL) SWIG_fail;
32585 temp5 = true;
32586 }
32587 }
32588 if (obj5) {
32589 {
32590 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32591 if (SWIG_arg_fail(6)) SWIG_fail;
32592 }
32593 }
32594 {
32595 PyThreadState* __tstate = wxPyBeginAllowThreads();
32596 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32597
32598 wxPyEndAllowThreads(__tstate);
32599 if (PyErr_Occurred()) SWIG_fail;
32600 }
32601 {
32602 resultobj = wxPyMake_wxObject(result, 0);
32603 }
32604 {
32605 if (temp4)
32606 delete arg4;
32607 }
32608 {
32609 if (temp5)
32610 delete arg5;
32611 }
32612 return resultobj;
32613 fail:
32614 {
32615 if (temp4)
32616 delete arg4;
32617 }
32618 {
32619 if (temp5)
32620 delete arg5;
32621 }
32622 return NULL;
32623 }
32624
32625
32626 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32627 PyObject *resultobj;
32628 wxMenu *arg1 = (wxMenu *) 0 ;
32629 size_t arg2 ;
32630 wxMenuItem *result;
32631 PyObject * obj0 = 0 ;
32632 PyObject * obj1 = 0 ;
32633 char *kwnames[] = {
32634 (char *) "self",(char *) "pos", NULL
32635 };
32636
32637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32639 if (SWIG_arg_fail(1)) SWIG_fail;
32640 {
32641 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32642 if (SWIG_arg_fail(2)) SWIG_fail;
32643 }
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32647
32648 wxPyEndAllowThreads(__tstate);
32649 if (PyErr_Occurred()) SWIG_fail;
32650 }
32651 {
32652 resultobj = wxPyMake_wxObject(result, 0);
32653 }
32654 return resultobj;
32655 fail:
32656 return NULL;
32657 }
32658
32659
32660 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32661 PyObject *resultobj;
32662 wxMenu *arg1 = (wxMenu *) 0 ;
32663 size_t arg2 ;
32664 int arg3 ;
32665 wxString *arg4 = 0 ;
32666 wxString const &arg5_defvalue = wxPyEmptyString ;
32667 wxString *arg5 = (wxString *) &arg5_defvalue ;
32668 wxMenuItem *result;
32669 bool temp4 = false ;
32670 bool temp5 = false ;
32671 PyObject * obj0 = 0 ;
32672 PyObject * obj1 = 0 ;
32673 PyObject * obj2 = 0 ;
32674 PyObject * obj3 = 0 ;
32675 PyObject * obj4 = 0 ;
32676 char *kwnames[] = {
32677 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32678 };
32679
32680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32682 if (SWIG_arg_fail(1)) SWIG_fail;
32683 {
32684 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32685 if (SWIG_arg_fail(2)) SWIG_fail;
32686 }
32687 {
32688 arg3 = (int)(SWIG_As_int(obj2));
32689 if (SWIG_arg_fail(3)) SWIG_fail;
32690 }
32691 {
32692 arg4 = wxString_in_helper(obj3);
32693 if (arg4 == NULL) SWIG_fail;
32694 temp4 = true;
32695 }
32696 if (obj4) {
32697 {
32698 arg5 = wxString_in_helper(obj4);
32699 if (arg5 == NULL) SWIG_fail;
32700 temp5 = true;
32701 }
32702 }
32703 {
32704 PyThreadState* __tstate = wxPyBeginAllowThreads();
32705 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32706
32707 wxPyEndAllowThreads(__tstate);
32708 if (PyErr_Occurred()) SWIG_fail;
32709 }
32710 {
32711 resultobj = wxPyMake_wxObject(result, 0);
32712 }
32713 {
32714 if (temp4)
32715 delete arg4;
32716 }
32717 {
32718 if (temp5)
32719 delete arg5;
32720 }
32721 return resultobj;
32722 fail:
32723 {
32724 if (temp4)
32725 delete arg4;
32726 }
32727 {
32728 if (temp5)
32729 delete arg5;
32730 }
32731 return NULL;
32732 }
32733
32734
32735 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32736 PyObject *resultobj;
32737 wxMenu *arg1 = (wxMenu *) 0 ;
32738 size_t arg2 ;
32739 int arg3 ;
32740 wxString *arg4 = 0 ;
32741 wxString const &arg5_defvalue = wxPyEmptyString ;
32742 wxString *arg5 = (wxString *) &arg5_defvalue ;
32743 wxMenuItem *result;
32744 bool temp4 = false ;
32745 bool temp5 = false ;
32746 PyObject * obj0 = 0 ;
32747 PyObject * obj1 = 0 ;
32748 PyObject * obj2 = 0 ;
32749 PyObject * obj3 = 0 ;
32750 PyObject * obj4 = 0 ;
32751 char *kwnames[] = {
32752 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32753 };
32754
32755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32757 if (SWIG_arg_fail(1)) SWIG_fail;
32758 {
32759 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32760 if (SWIG_arg_fail(2)) SWIG_fail;
32761 }
32762 {
32763 arg3 = (int)(SWIG_As_int(obj2));
32764 if (SWIG_arg_fail(3)) SWIG_fail;
32765 }
32766 {
32767 arg4 = wxString_in_helper(obj3);
32768 if (arg4 == NULL) SWIG_fail;
32769 temp4 = true;
32770 }
32771 if (obj4) {
32772 {
32773 arg5 = wxString_in_helper(obj4);
32774 if (arg5 == NULL) SWIG_fail;
32775 temp5 = true;
32776 }
32777 }
32778 {
32779 PyThreadState* __tstate = wxPyBeginAllowThreads();
32780 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32781
32782 wxPyEndAllowThreads(__tstate);
32783 if (PyErr_Occurred()) SWIG_fail;
32784 }
32785 {
32786 resultobj = wxPyMake_wxObject(result, 0);
32787 }
32788 {
32789 if (temp4)
32790 delete arg4;
32791 }
32792 {
32793 if (temp5)
32794 delete arg5;
32795 }
32796 return resultobj;
32797 fail:
32798 {
32799 if (temp4)
32800 delete arg4;
32801 }
32802 {
32803 if (temp5)
32804 delete arg5;
32805 }
32806 return NULL;
32807 }
32808
32809
32810 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32811 PyObject *resultobj;
32812 wxMenu *arg1 = (wxMenu *) 0 ;
32813 size_t arg2 ;
32814 int arg3 ;
32815 wxString *arg4 = 0 ;
32816 wxMenu *arg5 = (wxMenu *) 0 ;
32817 wxString const &arg6_defvalue = wxPyEmptyString ;
32818 wxString *arg6 = (wxString *) &arg6_defvalue ;
32819 wxMenuItem *result;
32820 bool temp4 = false ;
32821 bool temp6 = false ;
32822 PyObject * obj0 = 0 ;
32823 PyObject * obj1 = 0 ;
32824 PyObject * obj2 = 0 ;
32825 PyObject * obj3 = 0 ;
32826 PyObject * obj4 = 0 ;
32827 PyObject * obj5 = 0 ;
32828 char *kwnames[] = {
32829 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32830 };
32831
32832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32834 if (SWIG_arg_fail(1)) SWIG_fail;
32835 {
32836 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32837 if (SWIG_arg_fail(2)) SWIG_fail;
32838 }
32839 {
32840 arg3 = (int)(SWIG_As_int(obj2));
32841 if (SWIG_arg_fail(3)) SWIG_fail;
32842 }
32843 {
32844 arg4 = wxString_in_helper(obj3);
32845 if (arg4 == NULL) SWIG_fail;
32846 temp4 = true;
32847 }
32848 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32849 if (SWIG_arg_fail(5)) SWIG_fail;
32850 if (obj5) {
32851 {
32852 arg6 = wxString_in_helper(obj5);
32853 if (arg6 == NULL) SWIG_fail;
32854 temp6 = true;
32855 }
32856 }
32857 {
32858 PyThreadState* __tstate = wxPyBeginAllowThreads();
32859 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32860
32861 wxPyEndAllowThreads(__tstate);
32862 if (PyErr_Occurred()) SWIG_fail;
32863 }
32864 {
32865 resultobj = wxPyMake_wxObject(result, 0);
32866 }
32867 {
32868 if (temp4)
32869 delete arg4;
32870 }
32871 {
32872 if (temp6)
32873 delete arg6;
32874 }
32875 return resultobj;
32876 fail:
32877 {
32878 if (temp4)
32879 delete arg4;
32880 }
32881 {
32882 if (temp6)
32883 delete arg6;
32884 }
32885 return NULL;
32886 }
32887
32888
32889 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32890 PyObject *resultobj;
32891 wxMenu *arg1 = (wxMenu *) 0 ;
32892 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32893 wxMenuItem *result;
32894 PyObject * obj0 = 0 ;
32895 PyObject * obj1 = 0 ;
32896 char *kwnames[] = {
32897 (char *) "self",(char *) "item", NULL
32898 };
32899
32900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32902 if (SWIG_arg_fail(1)) SWIG_fail;
32903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32904 if (SWIG_arg_fail(2)) SWIG_fail;
32905 {
32906 PyThreadState* __tstate = wxPyBeginAllowThreads();
32907 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32908
32909 wxPyEndAllowThreads(__tstate);
32910 if (PyErr_Occurred()) SWIG_fail;
32911 }
32912 {
32913 resultobj = wxPyMake_wxObject(result, 0);
32914 }
32915 return resultobj;
32916 fail:
32917 return NULL;
32918 }
32919
32920
32921 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32922 PyObject *resultobj;
32923 wxMenu *arg1 = (wxMenu *) 0 ;
32924 int arg2 ;
32925 wxString *arg3 = 0 ;
32926 wxString const &arg4_defvalue = wxPyEmptyString ;
32927 wxString *arg4 = (wxString *) &arg4_defvalue ;
32928 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32929 wxMenuItem *result;
32930 bool temp3 = false ;
32931 bool temp4 = false ;
32932 PyObject * obj0 = 0 ;
32933 PyObject * obj1 = 0 ;
32934 PyObject * obj2 = 0 ;
32935 PyObject * obj3 = 0 ;
32936 PyObject * obj4 = 0 ;
32937 char *kwnames[] = {
32938 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32939 };
32940
32941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32943 if (SWIG_arg_fail(1)) SWIG_fail;
32944 {
32945 arg2 = (int)(SWIG_As_int(obj1));
32946 if (SWIG_arg_fail(2)) SWIG_fail;
32947 }
32948 {
32949 arg3 = wxString_in_helper(obj2);
32950 if (arg3 == NULL) SWIG_fail;
32951 temp3 = true;
32952 }
32953 if (obj3) {
32954 {
32955 arg4 = wxString_in_helper(obj3);
32956 if (arg4 == NULL) SWIG_fail;
32957 temp4 = true;
32958 }
32959 }
32960 if (obj4) {
32961 {
32962 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32963 if (SWIG_arg_fail(5)) SWIG_fail;
32964 }
32965 }
32966 {
32967 PyThreadState* __tstate = wxPyBeginAllowThreads();
32968 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32969
32970 wxPyEndAllowThreads(__tstate);
32971 if (PyErr_Occurred()) SWIG_fail;
32972 }
32973 {
32974 resultobj = wxPyMake_wxObject(result, 0);
32975 }
32976 {
32977 if (temp3)
32978 delete arg3;
32979 }
32980 {
32981 if (temp4)
32982 delete arg4;
32983 }
32984 return resultobj;
32985 fail:
32986 {
32987 if (temp3)
32988 delete arg3;
32989 }
32990 {
32991 if (temp4)
32992 delete arg4;
32993 }
32994 return NULL;
32995 }
32996
32997
32998 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32999 PyObject *resultobj;
33000 wxMenu *arg1 = (wxMenu *) 0 ;
33001 wxMenuItem *result;
33002 PyObject * obj0 = 0 ;
33003 char *kwnames[] = {
33004 (char *) "self", NULL
33005 };
33006
33007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33009 if (SWIG_arg_fail(1)) SWIG_fail;
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 result = (wxMenuItem *)(arg1)->PrependSeparator();
33013
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 {
33018 resultobj = wxPyMake_wxObject(result, 0);
33019 }
33020 return resultobj;
33021 fail:
33022 return NULL;
33023 }
33024
33025
33026 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33027 PyObject *resultobj;
33028 wxMenu *arg1 = (wxMenu *) 0 ;
33029 int arg2 ;
33030 wxString *arg3 = 0 ;
33031 wxString const &arg4_defvalue = wxPyEmptyString ;
33032 wxString *arg4 = (wxString *) &arg4_defvalue ;
33033 wxMenuItem *result;
33034 bool temp3 = false ;
33035 bool temp4 = false ;
33036 PyObject * obj0 = 0 ;
33037 PyObject * obj1 = 0 ;
33038 PyObject * obj2 = 0 ;
33039 PyObject * obj3 = 0 ;
33040 char *kwnames[] = {
33041 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33042 };
33043
33044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33046 if (SWIG_arg_fail(1)) SWIG_fail;
33047 {
33048 arg2 = (int)(SWIG_As_int(obj1));
33049 if (SWIG_arg_fail(2)) SWIG_fail;
33050 }
33051 {
33052 arg3 = wxString_in_helper(obj2);
33053 if (arg3 == NULL) SWIG_fail;
33054 temp3 = true;
33055 }
33056 if (obj3) {
33057 {
33058 arg4 = wxString_in_helper(obj3);
33059 if (arg4 == NULL) SWIG_fail;
33060 temp4 = true;
33061 }
33062 }
33063 {
33064 PyThreadState* __tstate = wxPyBeginAllowThreads();
33065 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33066
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 {
33071 resultobj = wxPyMake_wxObject(result, 0);
33072 }
33073 {
33074 if (temp3)
33075 delete arg3;
33076 }
33077 {
33078 if (temp4)
33079 delete arg4;
33080 }
33081 return resultobj;
33082 fail:
33083 {
33084 if (temp3)
33085 delete arg3;
33086 }
33087 {
33088 if (temp4)
33089 delete arg4;
33090 }
33091 return NULL;
33092 }
33093
33094
33095 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33096 PyObject *resultobj;
33097 wxMenu *arg1 = (wxMenu *) 0 ;
33098 int arg2 ;
33099 wxString *arg3 = 0 ;
33100 wxString const &arg4_defvalue = wxPyEmptyString ;
33101 wxString *arg4 = (wxString *) &arg4_defvalue ;
33102 wxMenuItem *result;
33103 bool temp3 = false ;
33104 bool temp4 = false ;
33105 PyObject * obj0 = 0 ;
33106 PyObject * obj1 = 0 ;
33107 PyObject * obj2 = 0 ;
33108 PyObject * obj3 = 0 ;
33109 char *kwnames[] = {
33110 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33111 };
33112
33113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33115 if (SWIG_arg_fail(1)) SWIG_fail;
33116 {
33117 arg2 = (int)(SWIG_As_int(obj1));
33118 if (SWIG_arg_fail(2)) SWIG_fail;
33119 }
33120 {
33121 arg3 = wxString_in_helper(obj2);
33122 if (arg3 == NULL) SWIG_fail;
33123 temp3 = true;
33124 }
33125 if (obj3) {
33126 {
33127 arg4 = wxString_in_helper(obj3);
33128 if (arg4 == NULL) SWIG_fail;
33129 temp4 = true;
33130 }
33131 }
33132 {
33133 PyThreadState* __tstate = wxPyBeginAllowThreads();
33134 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33135
33136 wxPyEndAllowThreads(__tstate);
33137 if (PyErr_Occurred()) SWIG_fail;
33138 }
33139 {
33140 resultobj = wxPyMake_wxObject(result, 0);
33141 }
33142 {
33143 if (temp3)
33144 delete arg3;
33145 }
33146 {
33147 if (temp4)
33148 delete arg4;
33149 }
33150 return resultobj;
33151 fail:
33152 {
33153 if (temp3)
33154 delete arg3;
33155 }
33156 {
33157 if (temp4)
33158 delete arg4;
33159 }
33160 return NULL;
33161 }
33162
33163
33164 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33165 PyObject *resultobj;
33166 wxMenu *arg1 = (wxMenu *) 0 ;
33167 int arg2 ;
33168 wxString *arg3 = 0 ;
33169 wxMenu *arg4 = (wxMenu *) 0 ;
33170 wxString const &arg5_defvalue = wxPyEmptyString ;
33171 wxString *arg5 = (wxString *) &arg5_defvalue ;
33172 wxMenuItem *result;
33173 bool temp3 = false ;
33174 bool temp5 = false ;
33175 PyObject * obj0 = 0 ;
33176 PyObject * obj1 = 0 ;
33177 PyObject * obj2 = 0 ;
33178 PyObject * obj3 = 0 ;
33179 PyObject * obj4 = 0 ;
33180 char *kwnames[] = {
33181 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33182 };
33183
33184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33186 if (SWIG_arg_fail(1)) SWIG_fail;
33187 {
33188 arg2 = (int)(SWIG_As_int(obj1));
33189 if (SWIG_arg_fail(2)) SWIG_fail;
33190 }
33191 {
33192 arg3 = wxString_in_helper(obj2);
33193 if (arg3 == NULL) SWIG_fail;
33194 temp3 = true;
33195 }
33196 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33197 if (SWIG_arg_fail(4)) SWIG_fail;
33198 if (obj4) {
33199 {
33200 arg5 = wxString_in_helper(obj4);
33201 if (arg5 == NULL) SWIG_fail;
33202 temp5 = true;
33203 }
33204 }
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33208
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 {
33213 resultobj = wxPyMake_wxObject(result, 0);
33214 }
33215 {
33216 if (temp3)
33217 delete arg3;
33218 }
33219 {
33220 if (temp5)
33221 delete arg5;
33222 }
33223 return resultobj;
33224 fail:
33225 {
33226 if (temp3)
33227 delete arg3;
33228 }
33229 {
33230 if (temp5)
33231 delete arg5;
33232 }
33233 return NULL;
33234 }
33235
33236
33237 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33238 PyObject *resultobj;
33239 wxMenu *arg1 = (wxMenu *) 0 ;
33240 int arg2 ;
33241 wxMenuItem *result;
33242 PyObject * obj0 = 0 ;
33243 PyObject * obj1 = 0 ;
33244 char *kwnames[] = {
33245 (char *) "self",(char *) "id", NULL
33246 };
33247
33248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33250 if (SWIG_arg_fail(1)) SWIG_fail;
33251 {
33252 arg2 = (int)(SWIG_As_int(obj1));
33253 if (SWIG_arg_fail(2)) SWIG_fail;
33254 }
33255 {
33256 PyThreadState* __tstate = wxPyBeginAllowThreads();
33257 result = (wxMenuItem *)(arg1)->Remove(arg2);
33258
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 {
33263 resultobj = wxPyMake_wxObject(result, 0);
33264 }
33265 return resultobj;
33266 fail:
33267 return NULL;
33268 }
33269
33270
33271 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33272 PyObject *resultobj;
33273 wxMenu *arg1 = (wxMenu *) 0 ;
33274 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33275 wxMenuItem *result;
33276 PyObject * obj0 = 0 ;
33277 PyObject * obj1 = 0 ;
33278 char *kwnames[] = {
33279 (char *) "self",(char *) "item", NULL
33280 };
33281
33282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33284 if (SWIG_arg_fail(1)) SWIG_fail;
33285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33286 if (SWIG_arg_fail(2)) SWIG_fail;
33287 {
33288 PyThreadState* __tstate = wxPyBeginAllowThreads();
33289 result = (wxMenuItem *)(arg1)->Remove(arg2);
33290
33291 wxPyEndAllowThreads(__tstate);
33292 if (PyErr_Occurred()) SWIG_fail;
33293 }
33294 {
33295 resultobj = wxPyMake_wxObject(result, 0);
33296 }
33297 return resultobj;
33298 fail:
33299 return NULL;
33300 }
33301
33302
33303 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33304 PyObject *resultobj;
33305 wxMenu *arg1 = (wxMenu *) 0 ;
33306 int arg2 ;
33307 bool result;
33308 PyObject * obj0 = 0 ;
33309 PyObject * obj1 = 0 ;
33310 char *kwnames[] = {
33311 (char *) "self",(char *) "id", NULL
33312 };
33313
33314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33316 if (SWIG_arg_fail(1)) SWIG_fail;
33317 {
33318 arg2 = (int)(SWIG_As_int(obj1));
33319 if (SWIG_arg_fail(2)) SWIG_fail;
33320 }
33321 {
33322 PyThreadState* __tstate = wxPyBeginAllowThreads();
33323 result = (bool)(arg1)->Delete(arg2);
33324
33325 wxPyEndAllowThreads(__tstate);
33326 if (PyErr_Occurred()) SWIG_fail;
33327 }
33328 {
33329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33330 }
33331 return resultobj;
33332 fail:
33333 return NULL;
33334 }
33335
33336
33337 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33338 PyObject *resultobj;
33339 wxMenu *arg1 = (wxMenu *) 0 ;
33340 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33341 bool result;
33342 PyObject * obj0 = 0 ;
33343 PyObject * obj1 = 0 ;
33344 char *kwnames[] = {
33345 (char *) "self",(char *) "item", NULL
33346 };
33347
33348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33350 if (SWIG_arg_fail(1)) SWIG_fail;
33351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33352 if (SWIG_arg_fail(2)) SWIG_fail;
33353 {
33354 PyThreadState* __tstate = wxPyBeginAllowThreads();
33355 result = (bool)(arg1)->Delete(arg2);
33356
33357 wxPyEndAllowThreads(__tstate);
33358 if (PyErr_Occurred()) SWIG_fail;
33359 }
33360 {
33361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33362 }
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33370 PyObject *resultobj;
33371 wxMenu *arg1 = (wxMenu *) 0 ;
33372 PyObject * obj0 = 0 ;
33373 char *kwnames[] = {
33374 (char *) "self", NULL
33375 };
33376
33377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33379 if (SWIG_arg_fail(1)) SWIG_fail;
33380 {
33381 PyThreadState* __tstate = wxPyBeginAllowThreads();
33382 wxMenu_Destroy(arg1);
33383
33384 wxPyEndAllowThreads(__tstate);
33385 if (PyErr_Occurred()) SWIG_fail;
33386 }
33387 Py_INCREF(Py_None); resultobj = Py_None;
33388 return resultobj;
33389 fail:
33390 return NULL;
33391 }
33392
33393
33394 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33395 PyObject *resultobj;
33396 wxMenu *arg1 = (wxMenu *) 0 ;
33397 int arg2 ;
33398 bool result;
33399 PyObject * obj0 = 0 ;
33400 PyObject * obj1 = 0 ;
33401 char *kwnames[] = {
33402 (char *) "self",(char *) "id", NULL
33403 };
33404
33405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33407 if (SWIG_arg_fail(1)) SWIG_fail;
33408 {
33409 arg2 = (int)(SWIG_As_int(obj1));
33410 if (SWIG_arg_fail(2)) SWIG_fail;
33411 }
33412 {
33413 PyThreadState* __tstate = wxPyBeginAllowThreads();
33414 result = (bool)(arg1)->Destroy(arg2);
33415
33416 wxPyEndAllowThreads(__tstate);
33417 if (PyErr_Occurred()) SWIG_fail;
33418 }
33419 {
33420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33421 }
33422 return resultobj;
33423 fail:
33424 return NULL;
33425 }
33426
33427
33428 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33429 PyObject *resultobj;
33430 wxMenu *arg1 = (wxMenu *) 0 ;
33431 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33432 bool result;
33433 PyObject * obj0 = 0 ;
33434 PyObject * obj1 = 0 ;
33435 char *kwnames[] = {
33436 (char *) "self",(char *) "item", NULL
33437 };
33438
33439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33441 if (SWIG_arg_fail(1)) SWIG_fail;
33442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33443 if (SWIG_arg_fail(2)) SWIG_fail;
33444 {
33445 PyThreadState* __tstate = wxPyBeginAllowThreads();
33446 result = (bool)(arg1)->Destroy(arg2);
33447
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 {
33452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33453 }
33454 return resultobj;
33455 fail:
33456 return NULL;
33457 }
33458
33459
33460 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33461 PyObject *resultobj;
33462 wxMenu *arg1 = (wxMenu *) 0 ;
33463 size_t result;
33464 PyObject * obj0 = 0 ;
33465 char *kwnames[] = {
33466 (char *) "self", NULL
33467 };
33468
33469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33471 if (SWIG_arg_fail(1)) SWIG_fail;
33472 {
33473 PyThreadState* __tstate = wxPyBeginAllowThreads();
33474 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33475
33476 wxPyEndAllowThreads(__tstate);
33477 if (PyErr_Occurred()) SWIG_fail;
33478 }
33479 {
33480 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33481 }
33482 return resultobj;
33483 fail:
33484 return NULL;
33485 }
33486
33487
33488 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33489 PyObject *resultobj;
33490 wxMenu *arg1 = (wxMenu *) 0 ;
33491 PyObject *result;
33492 PyObject * obj0 = 0 ;
33493 char *kwnames[] = {
33494 (char *) "self", NULL
33495 };
33496
33497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33499 if (SWIG_arg_fail(1)) SWIG_fail;
33500 {
33501 PyThreadState* __tstate = wxPyBeginAllowThreads();
33502 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33503
33504 wxPyEndAllowThreads(__tstate);
33505 if (PyErr_Occurred()) SWIG_fail;
33506 }
33507 resultobj = result;
33508 return resultobj;
33509 fail:
33510 return NULL;
33511 }
33512
33513
33514 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33515 PyObject *resultobj;
33516 wxMenu *arg1 = (wxMenu *) 0 ;
33517 wxString *arg2 = 0 ;
33518 int result;
33519 bool temp2 = false ;
33520 PyObject * obj0 = 0 ;
33521 PyObject * obj1 = 0 ;
33522 char *kwnames[] = {
33523 (char *) "self",(char *) "item", NULL
33524 };
33525
33526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33528 if (SWIG_arg_fail(1)) SWIG_fail;
33529 {
33530 arg2 = wxString_in_helper(obj1);
33531 if (arg2 == NULL) SWIG_fail;
33532 temp2 = true;
33533 }
33534 {
33535 PyThreadState* __tstate = wxPyBeginAllowThreads();
33536 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33537
33538 wxPyEndAllowThreads(__tstate);
33539 if (PyErr_Occurred()) SWIG_fail;
33540 }
33541 {
33542 resultobj = SWIG_From_int((int)(result));
33543 }
33544 {
33545 if (temp2)
33546 delete arg2;
33547 }
33548 return resultobj;
33549 fail:
33550 {
33551 if (temp2)
33552 delete arg2;
33553 }
33554 return NULL;
33555 }
33556
33557
33558 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33559 PyObject *resultobj;
33560 wxMenu *arg1 = (wxMenu *) 0 ;
33561 int arg2 ;
33562 wxMenuItem *result;
33563 PyObject * obj0 = 0 ;
33564 PyObject * obj1 = 0 ;
33565 char *kwnames[] = {
33566 (char *) "self",(char *) "id", NULL
33567 };
33568
33569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33571 if (SWIG_arg_fail(1)) SWIG_fail;
33572 {
33573 arg2 = (int)(SWIG_As_int(obj1));
33574 if (SWIG_arg_fail(2)) SWIG_fail;
33575 }
33576 {
33577 PyThreadState* __tstate = wxPyBeginAllowThreads();
33578 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33579
33580 wxPyEndAllowThreads(__tstate);
33581 if (PyErr_Occurred()) SWIG_fail;
33582 }
33583 {
33584 resultobj = wxPyMake_wxObject(result, 0);
33585 }
33586 return resultobj;
33587 fail:
33588 return NULL;
33589 }
33590
33591
33592 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33593 PyObject *resultobj;
33594 wxMenu *arg1 = (wxMenu *) 0 ;
33595 size_t arg2 ;
33596 wxMenuItem *result;
33597 PyObject * obj0 = 0 ;
33598 PyObject * obj1 = 0 ;
33599 char *kwnames[] = {
33600 (char *) "self",(char *) "position", NULL
33601 };
33602
33603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33605 if (SWIG_arg_fail(1)) SWIG_fail;
33606 {
33607 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33608 if (SWIG_arg_fail(2)) SWIG_fail;
33609 }
33610 {
33611 PyThreadState* __tstate = wxPyBeginAllowThreads();
33612 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33613
33614 wxPyEndAllowThreads(__tstate);
33615 if (PyErr_Occurred()) SWIG_fail;
33616 }
33617 {
33618 resultobj = wxPyMake_wxObject(result, 0);
33619 }
33620 return resultobj;
33621 fail:
33622 return NULL;
33623 }
33624
33625
33626 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33627 PyObject *resultobj;
33628 wxMenu *arg1 = (wxMenu *) 0 ;
33629 int arg2 ;
33630 bool arg3 ;
33631 PyObject * obj0 = 0 ;
33632 PyObject * obj1 = 0 ;
33633 PyObject * obj2 = 0 ;
33634 char *kwnames[] = {
33635 (char *) "self",(char *) "id",(char *) "enable", NULL
33636 };
33637
33638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33640 if (SWIG_arg_fail(1)) SWIG_fail;
33641 {
33642 arg2 = (int)(SWIG_As_int(obj1));
33643 if (SWIG_arg_fail(2)) SWIG_fail;
33644 }
33645 {
33646 arg3 = (bool)(SWIG_As_bool(obj2));
33647 if (SWIG_arg_fail(3)) SWIG_fail;
33648 }
33649 {
33650 PyThreadState* __tstate = wxPyBeginAllowThreads();
33651 (arg1)->Enable(arg2,arg3);
33652
33653 wxPyEndAllowThreads(__tstate);
33654 if (PyErr_Occurred()) SWIG_fail;
33655 }
33656 Py_INCREF(Py_None); resultobj = Py_None;
33657 return resultobj;
33658 fail:
33659 return NULL;
33660 }
33661
33662
33663 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33664 PyObject *resultobj;
33665 wxMenu *arg1 = (wxMenu *) 0 ;
33666 int arg2 ;
33667 bool result;
33668 PyObject * obj0 = 0 ;
33669 PyObject * obj1 = 0 ;
33670 char *kwnames[] = {
33671 (char *) "self",(char *) "id", NULL
33672 };
33673
33674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33676 if (SWIG_arg_fail(1)) SWIG_fail;
33677 {
33678 arg2 = (int)(SWIG_As_int(obj1));
33679 if (SWIG_arg_fail(2)) SWIG_fail;
33680 }
33681 {
33682 PyThreadState* __tstate = wxPyBeginAllowThreads();
33683 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33684
33685 wxPyEndAllowThreads(__tstate);
33686 if (PyErr_Occurred()) SWIG_fail;
33687 }
33688 {
33689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33690 }
33691 return resultobj;
33692 fail:
33693 return NULL;
33694 }
33695
33696
33697 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33698 PyObject *resultobj;
33699 wxMenu *arg1 = (wxMenu *) 0 ;
33700 int arg2 ;
33701 bool arg3 ;
33702 PyObject * obj0 = 0 ;
33703 PyObject * obj1 = 0 ;
33704 PyObject * obj2 = 0 ;
33705 char *kwnames[] = {
33706 (char *) "self",(char *) "id",(char *) "check", NULL
33707 };
33708
33709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33711 if (SWIG_arg_fail(1)) SWIG_fail;
33712 {
33713 arg2 = (int)(SWIG_As_int(obj1));
33714 if (SWIG_arg_fail(2)) SWIG_fail;
33715 }
33716 {
33717 arg3 = (bool)(SWIG_As_bool(obj2));
33718 if (SWIG_arg_fail(3)) SWIG_fail;
33719 }
33720 {
33721 PyThreadState* __tstate = wxPyBeginAllowThreads();
33722 (arg1)->Check(arg2,arg3);
33723
33724 wxPyEndAllowThreads(__tstate);
33725 if (PyErr_Occurred()) SWIG_fail;
33726 }
33727 Py_INCREF(Py_None); resultobj = Py_None;
33728 return resultobj;
33729 fail:
33730 return NULL;
33731 }
33732
33733
33734 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33735 PyObject *resultobj;
33736 wxMenu *arg1 = (wxMenu *) 0 ;
33737 int arg2 ;
33738 bool result;
33739 PyObject * obj0 = 0 ;
33740 PyObject * obj1 = 0 ;
33741 char *kwnames[] = {
33742 (char *) "self",(char *) "id", NULL
33743 };
33744
33745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33747 if (SWIG_arg_fail(1)) SWIG_fail;
33748 {
33749 arg2 = (int)(SWIG_As_int(obj1));
33750 if (SWIG_arg_fail(2)) SWIG_fail;
33751 }
33752 {
33753 PyThreadState* __tstate = wxPyBeginAllowThreads();
33754 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33755
33756 wxPyEndAllowThreads(__tstate);
33757 if (PyErr_Occurred()) SWIG_fail;
33758 }
33759 {
33760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33761 }
33762 return resultobj;
33763 fail:
33764 return NULL;
33765 }
33766
33767
33768 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33769 PyObject *resultobj;
33770 wxMenu *arg1 = (wxMenu *) 0 ;
33771 int arg2 ;
33772 wxString *arg3 = 0 ;
33773 bool temp3 = false ;
33774 PyObject * obj0 = 0 ;
33775 PyObject * obj1 = 0 ;
33776 PyObject * obj2 = 0 ;
33777 char *kwnames[] = {
33778 (char *) "self",(char *) "id",(char *) "label", NULL
33779 };
33780
33781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33783 if (SWIG_arg_fail(1)) SWIG_fail;
33784 {
33785 arg2 = (int)(SWIG_As_int(obj1));
33786 if (SWIG_arg_fail(2)) SWIG_fail;
33787 }
33788 {
33789 arg3 = wxString_in_helper(obj2);
33790 if (arg3 == NULL) SWIG_fail;
33791 temp3 = true;
33792 }
33793 {
33794 PyThreadState* __tstate = wxPyBeginAllowThreads();
33795 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33796
33797 wxPyEndAllowThreads(__tstate);
33798 if (PyErr_Occurred()) SWIG_fail;
33799 }
33800 Py_INCREF(Py_None); resultobj = Py_None;
33801 {
33802 if (temp3)
33803 delete arg3;
33804 }
33805 return resultobj;
33806 fail:
33807 {
33808 if (temp3)
33809 delete arg3;
33810 }
33811 return NULL;
33812 }
33813
33814
33815 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj;
33817 wxMenu *arg1 = (wxMenu *) 0 ;
33818 int arg2 ;
33819 wxString result;
33820 PyObject * obj0 = 0 ;
33821 PyObject * obj1 = 0 ;
33822 char *kwnames[] = {
33823 (char *) "self",(char *) "id", NULL
33824 };
33825
33826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33828 if (SWIG_arg_fail(1)) SWIG_fail;
33829 {
33830 arg2 = (int)(SWIG_As_int(obj1));
33831 if (SWIG_arg_fail(2)) SWIG_fail;
33832 }
33833 {
33834 PyThreadState* __tstate = wxPyBeginAllowThreads();
33835 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33836
33837 wxPyEndAllowThreads(__tstate);
33838 if (PyErr_Occurred()) SWIG_fail;
33839 }
33840 {
33841 #if wxUSE_UNICODE
33842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33843 #else
33844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33845 #endif
33846 }
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33854 PyObject *resultobj;
33855 wxMenu *arg1 = (wxMenu *) 0 ;
33856 int arg2 ;
33857 wxString *arg3 = 0 ;
33858 bool temp3 = false ;
33859 PyObject * obj0 = 0 ;
33860 PyObject * obj1 = 0 ;
33861 PyObject * obj2 = 0 ;
33862 char *kwnames[] = {
33863 (char *) "self",(char *) "id",(char *) "helpString", NULL
33864 };
33865
33866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
33871 if (SWIG_arg_fail(2)) SWIG_fail;
33872 }
33873 {
33874 arg3 = wxString_in_helper(obj2);
33875 if (arg3 == NULL) SWIG_fail;
33876 temp3 = true;
33877 }
33878 {
33879 PyThreadState* __tstate = wxPyBeginAllowThreads();
33880 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33881
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 Py_INCREF(Py_None); resultobj = Py_None;
33886 {
33887 if (temp3)
33888 delete arg3;
33889 }
33890 return resultobj;
33891 fail:
33892 {
33893 if (temp3)
33894 delete arg3;
33895 }
33896 return NULL;
33897 }
33898
33899
33900 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33901 PyObject *resultobj;
33902 wxMenu *arg1 = (wxMenu *) 0 ;
33903 int arg2 ;
33904 wxString result;
33905 PyObject * obj0 = 0 ;
33906 PyObject * obj1 = 0 ;
33907 char *kwnames[] = {
33908 (char *) "self",(char *) "id", NULL
33909 };
33910
33911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33913 if (SWIG_arg_fail(1)) SWIG_fail;
33914 {
33915 arg2 = (int)(SWIG_As_int(obj1));
33916 if (SWIG_arg_fail(2)) SWIG_fail;
33917 }
33918 {
33919 PyThreadState* __tstate = wxPyBeginAllowThreads();
33920 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33921
33922 wxPyEndAllowThreads(__tstate);
33923 if (PyErr_Occurred()) SWIG_fail;
33924 }
33925 {
33926 #if wxUSE_UNICODE
33927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33928 #else
33929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33930 #endif
33931 }
33932 return resultobj;
33933 fail:
33934 return NULL;
33935 }
33936
33937
33938 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33939 PyObject *resultobj;
33940 wxMenu *arg1 = (wxMenu *) 0 ;
33941 wxString *arg2 = 0 ;
33942 bool temp2 = false ;
33943 PyObject * obj0 = 0 ;
33944 PyObject * obj1 = 0 ;
33945 char *kwnames[] = {
33946 (char *) "self",(char *) "title", NULL
33947 };
33948
33949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33951 if (SWIG_arg_fail(1)) SWIG_fail;
33952 {
33953 arg2 = wxString_in_helper(obj1);
33954 if (arg2 == NULL) SWIG_fail;
33955 temp2 = true;
33956 }
33957 {
33958 PyThreadState* __tstate = wxPyBeginAllowThreads();
33959 (arg1)->SetTitle((wxString const &)*arg2);
33960
33961 wxPyEndAllowThreads(__tstate);
33962 if (PyErr_Occurred()) SWIG_fail;
33963 }
33964 Py_INCREF(Py_None); resultobj = Py_None;
33965 {
33966 if (temp2)
33967 delete arg2;
33968 }
33969 return resultobj;
33970 fail:
33971 {
33972 if (temp2)
33973 delete arg2;
33974 }
33975 return NULL;
33976 }
33977
33978
33979 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33980 PyObject *resultobj;
33981 wxMenu *arg1 = (wxMenu *) 0 ;
33982 wxString result;
33983 PyObject * obj0 = 0 ;
33984 char *kwnames[] = {
33985 (char *) "self", NULL
33986 };
33987
33988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33990 if (SWIG_arg_fail(1)) SWIG_fail;
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 result = ((wxMenu const *)arg1)->GetTitle();
33994
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 {
33999 #if wxUSE_UNICODE
34000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34001 #else
34002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34003 #endif
34004 }
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34012 PyObject *resultobj;
34013 wxMenu *arg1 = (wxMenu *) 0 ;
34014 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34015 PyObject * obj0 = 0 ;
34016 PyObject * obj1 = 0 ;
34017 char *kwnames[] = {
34018 (char *) "self",(char *) "handler", NULL
34019 };
34020
34021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34023 if (SWIG_arg_fail(1)) SWIG_fail;
34024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34025 if (SWIG_arg_fail(2)) SWIG_fail;
34026 {
34027 PyThreadState* __tstate = wxPyBeginAllowThreads();
34028 (arg1)->SetEventHandler(arg2);
34029
34030 wxPyEndAllowThreads(__tstate);
34031 if (PyErr_Occurred()) SWIG_fail;
34032 }
34033 Py_INCREF(Py_None); resultobj = Py_None;
34034 return resultobj;
34035 fail:
34036 return NULL;
34037 }
34038
34039
34040 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34041 PyObject *resultobj;
34042 wxMenu *arg1 = (wxMenu *) 0 ;
34043 wxEvtHandler *result;
34044 PyObject * obj0 = 0 ;
34045 char *kwnames[] = {
34046 (char *) "self", NULL
34047 };
34048
34049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34051 if (SWIG_arg_fail(1)) SWIG_fail;
34052 {
34053 PyThreadState* __tstate = wxPyBeginAllowThreads();
34054 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34055
34056 wxPyEndAllowThreads(__tstate);
34057 if (PyErr_Occurred()) SWIG_fail;
34058 }
34059 {
34060 resultobj = wxPyMake_wxObject(result, 0);
34061 }
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34069 PyObject *resultobj;
34070 wxMenu *arg1 = (wxMenu *) 0 ;
34071 wxWindow *arg2 = (wxWindow *) 0 ;
34072 PyObject * obj0 = 0 ;
34073 PyObject * obj1 = 0 ;
34074 char *kwnames[] = {
34075 (char *) "self",(char *) "win", NULL
34076 };
34077
34078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34080 if (SWIG_arg_fail(1)) SWIG_fail;
34081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34082 if (SWIG_arg_fail(2)) SWIG_fail;
34083 {
34084 PyThreadState* __tstate = wxPyBeginAllowThreads();
34085 (arg1)->SetInvokingWindow(arg2);
34086
34087 wxPyEndAllowThreads(__tstate);
34088 if (PyErr_Occurred()) SWIG_fail;
34089 }
34090 Py_INCREF(Py_None); resultobj = Py_None;
34091 return resultobj;
34092 fail:
34093 return NULL;
34094 }
34095
34096
34097 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34098 PyObject *resultobj;
34099 wxMenu *arg1 = (wxMenu *) 0 ;
34100 wxWindow *result;
34101 PyObject * obj0 = 0 ;
34102 char *kwnames[] = {
34103 (char *) "self", NULL
34104 };
34105
34106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34108 if (SWIG_arg_fail(1)) SWIG_fail;
34109 {
34110 PyThreadState* __tstate = wxPyBeginAllowThreads();
34111 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34112
34113 wxPyEndAllowThreads(__tstate);
34114 if (PyErr_Occurred()) SWIG_fail;
34115 }
34116 {
34117 resultobj = wxPyMake_wxObject(result, 0);
34118 }
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34126 PyObject *resultobj;
34127 wxMenu *arg1 = (wxMenu *) 0 ;
34128 long result;
34129 PyObject * obj0 = 0 ;
34130 char *kwnames[] = {
34131 (char *) "self", NULL
34132 };
34133
34134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34136 if (SWIG_arg_fail(1)) SWIG_fail;
34137 {
34138 PyThreadState* __tstate = wxPyBeginAllowThreads();
34139 result = (long)((wxMenu const *)arg1)->GetStyle();
34140
34141 wxPyEndAllowThreads(__tstate);
34142 if (PyErr_Occurred()) SWIG_fail;
34143 }
34144 {
34145 resultobj = SWIG_From_long((long)(result));
34146 }
34147 return resultobj;
34148 fail:
34149 return NULL;
34150 }
34151
34152
34153 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34154 PyObject *resultobj;
34155 wxMenu *arg1 = (wxMenu *) 0 ;
34156 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34157 PyObject * obj0 = 0 ;
34158 PyObject * obj1 = 0 ;
34159 char *kwnames[] = {
34160 (char *) "self",(char *) "source", NULL
34161 };
34162
34163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34165 if (SWIG_arg_fail(1)) SWIG_fail;
34166 if (obj1) {
34167 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34168 if (SWIG_arg_fail(2)) SWIG_fail;
34169 }
34170 {
34171 PyThreadState* __tstate = wxPyBeginAllowThreads();
34172 (arg1)->UpdateUI(arg2);
34173
34174 wxPyEndAllowThreads(__tstate);
34175 if (PyErr_Occurred()) SWIG_fail;
34176 }
34177 Py_INCREF(Py_None); resultobj = Py_None;
34178 return resultobj;
34179 fail:
34180 return NULL;
34181 }
34182
34183
34184 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34185 PyObject *resultobj;
34186 wxMenu *arg1 = (wxMenu *) 0 ;
34187 wxMenuBar *result;
34188 PyObject * obj0 = 0 ;
34189 char *kwnames[] = {
34190 (char *) "self", NULL
34191 };
34192
34193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34195 if (SWIG_arg_fail(1)) SWIG_fail;
34196 {
34197 PyThreadState* __tstate = wxPyBeginAllowThreads();
34198 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34199
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 {
34204 resultobj = wxPyMake_wxObject(result, 0);
34205 }
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34213 PyObject *resultobj;
34214 wxMenu *arg1 = (wxMenu *) 0 ;
34215 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34216 PyObject * obj0 = 0 ;
34217 PyObject * obj1 = 0 ;
34218 char *kwnames[] = {
34219 (char *) "self",(char *) "menubar", NULL
34220 };
34221
34222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34224 if (SWIG_arg_fail(1)) SWIG_fail;
34225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34226 if (SWIG_arg_fail(2)) SWIG_fail;
34227 {
34228 PyThreadState* __tstate = wxPyBeginAllowThreads();
34229 (arg1)->Attach(arg2);
34230
34231 wxPyEndAllowThreads(__tstate);
34232 if (PyErr_Occurred()) SWIG_fail;
34233 }
34234 Py_INCREF(Py_None); resultobj = Py_None;
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34242 PyObject *resultobj;
34243 wxMenu *arg1 = (wxMenu *) 0 ;
34244 PyObject * obj0 = 0 ;
34245 char *kwnames[] = {
34246 (char *) "self", NULL
34247 };
34248
34249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34251 if (SWIG_arg_fail(1)) SWIG_fail;
34252 {
34253 PyThreadState* __tstate = wxPyBeginAllowThreads();
34254 (arg1)->Detach();
34255
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 Py_INCREF(Py_None); resultobj = Py_None;
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34267 PyObject *resultobj;
34268 wxMenu *arg1 = (wxMenu *) 0 ;
34269 bool result;
34270 PyObject * obj0 = 0 ;
34271 char *kwnames[] = {
34272 (char *) "self", NULL
34273 };
34274
34275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34277 if (SWIG_arg_fail(1)) SWIG_fail;
34278 {
34279 PyThreadState* __tstate = wxPyBeginAllowThreads();
34280 result = (bool)((wxMenu const *)arg1)->IsAttached();
34281
34282 wxPyEndAllowThreads(__tstate);
34283 if (PyErr_Occurred()) SWIG_fail;
34284 }
34285 {
34286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34287 }
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj;
34296 wxMenu *arg1 = (wxMenu *) 0 ;
34297 wxMenu *arg2 = (wxMenu *) 0 ;
34298 PyObject * obj0 = 0 ;
34299 PyObject * obj1 = 0 ;
34300 char *kwnames[] = {
34301 (char *) "self",(char *) "parent", NULL
34302 };
34303
34304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34306 if (SWIG_arg_fail(1)) SWIG_fail;
34307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34308 if (SWIG_arg_fail(2)) SWIG_fail;
34309 {
34310 PyThreadState* __tstate = wxPyBeginAllowThreads();
34311 (arg1)->SetParent(arg2);
34312
34313 wxPyEndAllowThreads(__tstate);
34314 if (PyErr_Occurred()) SWIG_fail;
34315 }
34316 Py_INCREF(Py_None); resultobj = Py_None;
34317 return resultobj;
34318 fail:
34319 return NULL;
34320 }
34321
34322
34323 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34324 PyObject *resultobj;
34325 wxMenu *arg1 = (wxMenu *) 0 ;
34326 wxMenu *result;
34327 PyObject * obj0 = 0 ;
34328 char *kwnames[] = {
34329 (char *) "self", NULL
34330 };
34331
34332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34334 if (SWIG_arg_fail(1)) SWIG_fail;
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34338
34339 wxPyEndAllowThreads(__tstate);
34340 if (PyErr_Occurred()) SWIG_fail;
34341 }
34342 {
34343 resultobj = wxPyMake_wxObject(result, 0);
34344 }
34345 return resultobj;
34346 fail:
34347 return NULL;
34348 }
34349
34350
34351 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34352 PyObject *obj;
34353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34354 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34355 Py_INCREF(obj);
34356 return Py_BuildValue((char *)"");
34357 }
34358 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34359 PyObject *resultobj;
34360 long arg1 = (long) 0 ;
34361 wxMenuBar *result;
34362 PyObject * obj0 = 0 ;
34363 char *kwnames[] = {
34364 (char *) "style", NULL
34365 };
34366
34367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34368 if (obj0) {
34369 {
34370 arg1 = (long)(SWIG_As_long(obj0));
34371 if (SWIG_arg_fail(1)) SWIG_fail;
34372 }
34373 }
34374 {
34375 if (!wxPyCheckForApp()) SWIG_fail;
34376 PyThreadState* __tstate = wxPyBeginAllowThreads();
34377 result = (wxMenuBar *)new wxMenuBar(arg1);
34378
34379 wxPyEndAllowThreads(__tstate);
34380 if (PyErr_Occurred()) SWIG_fail;
34381 }
34382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34383 return resultobj;
34384 fail:
34385 return NULL;
34386 }
34387
34388
34389 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34390 PyObject *resultobj;
34391 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34392 wxMenu *arg2 = (wxMenu *) 0 ;
34393 wxString *arg3 = 0 ;
34394 bool result;
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 *) "title", NULL
34401 };
34402
34403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34407 if (SWIG_arg_fail(2)) SWIG_fail;
34408 {
34409 arg3 = wxString_in_helper(obj2);
34410 if (arg3 == NULL) SWIG_fail;
34411 temp3 = true;
34412 }
34413 {
34414 PyThreadState* __tstate = wxPyBeginAllowThreads();
34415 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34416
34417 wxPyEndAllowThreads(__tstate);
34418 if (PyErr_Occurred()) SWIG_fail;
34419 }
34420 {
34421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34422 }
34423 {
34424 if (temp3)
34425 delete arg3;
34426 }
34427 return resultobj;
34428 fail:
34429 {
34430 if (temp3)
34431 delete arg3;
34432 }
34433 return NULL;
34434 }
34435
34436
34437 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34438 PyObject *resultobj;
34439 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34440 size_t arg2 ;
34441 wxMenu *arg3 = (wxMenu *) 0 ;
34442 wxString *arg4 = 0 ;
34443 bool result;
34444 bool temp4 = false ;
34445 PyObject * obj0 = 0 ;
34446 PyObject * obj1 = 0 ;
34447 PyObject * obj2 = 0 ;
34448 PyObject * obj3 = 0 ;
34449 char *kwnames[] = {
34450 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34451 };
34452
34453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34455 if (SWIG_arg_fail(1)) SWIG_fail;
34456 {
34457 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34458 if (SWIG_arg_fail(2)) SWIG_fail;
34459 }
34460 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34461 if (SWIG_arg_fail(3)) SWIG_fail;
34462 {
34463 arg4 = wxString_in_helper(obj3);
34464 if (arg4 == NULL) SWIG_fail;
34465 temp4 = true;
34466 }
34467 {
34468 PyThreadState* __tstate = wxPyBeginAllowThreads();
34469 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34470
34471 wxPyEndAllowThreads(__tstate);
34472 if (PyErr_Occurred()) SWIG_fail;
34473 }
34474 {
34475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34476 }
34477 {
34478 if (temp4)
34479 delete arg4;
34480 }
34481 return resultobj;
34482 fail:
34483 {
34484 if (temp4)
34485 delete arg4;
34486 }
34487 return NULL;
34488 }
34489
34490
34491 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34492 PyObject *resultobj;
34493 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34494 size_t result;
34495 PyObject * obj0 = 0 ;
34496 char *kwnames[] = {
34497 (char *) "self", NULL
34498 };
34499
34500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34502 if (SWIG_arg_fail(1)) SWIG_fail;
34503 {
34504 PyThreadState* __tstate = wxPyBeginAllowThreads();
34505 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34506
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 {
34511 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34512 }
34513 return resultobj;
34514 fail:
34515 return NULL;
34516 }
34517
34518
34519 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34520 PyObject *resultobj;
34521 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34522 size_t arg2 ;
34523 wxMenu *result;
34524 PyObject * obj0 = 0 ;
34525 PyObject * obj1 = 0 ;
34526 char *kwnames[] = {
34527 (char *) "self",(char *) "pos", NULL
34528 };
34529
34530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34532 if (SWIG_arg_fail(1)) SWIG_fail;
34533 {
34534 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34535 if (SWIG_arg_fail(2)) SWIG_fail;
34536 }
34537 {
34538 PyThreadState* __tstate = wxPyBeginAllowThreads();
34539 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34540
34541 wxPyEndAllowThreads(__tstate);
34542 if (PyErr_Occurred()) SWIG_fail;
34543 }
34544 {
34545 resultobj = wxPyMake_wxObject(result, 0);
34546 }
34547 return resultobj;
34548 fail:
34549 return NULL;
34550 }
34551
34552
34553 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34554 PyObject *resultobj;
34555 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34556 size_t arg2 ;
34557 wxMenu *arg3 = (wxMenu *) 0 ;
34558 wxString *arg4 = 0 ;
34559 wxMenu *result;
34560 bool temp4 = false ;
34561 PyObject * obj0 = 0 ;
34562 PyObject * obj1 = 0 ;
34563 PyObject * obj2 = 0 ;
34564 PyObject * obj3 = 0 ;
34565 char *kwnames[] = {
34566 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34567 };
34568
34569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34571 if (SWIG_arg_fail(1)) SWIG_fail;
34572 {
34573 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34574 if (SWIG_arg_fail(2)) SWIG_fail;
34575 }
34576 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34577 if (SWIG_arg_fail(3)) SWIG_fail;
34578 {
34579 arg4 = wxString_in_helper(obj3);
34580 if (arg4 == NULL) SWIG_fail;
34581 temp4 = true;
34582 }
34583 {
34584 PyThreadState* __tstate = wxPyBeginAllowThreads();
34585 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34586
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 {
34591 resultobj = wxPyMake_wxObject(result, 0);
34592 }
34593 {
34594 if (temp4)
34595 delete arg4;
34596 }
34597 return resultobj;
34598 fail:
34599 {
34600 if (temp4)
34601 delete arg4;
34602 }
34603 return NULL;
34604 }
34605
34606
34607 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34608 PyObject *resultobj;
34609 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34610 size_t arg2 ;
34611 wxMenu *result;
34612 PyObject * obj0 = 0 ;
34613 PyObject * obj1 = 0 ;
34614 char *kwnames[] = {
34615 (char *) "self",(char *) "pos", NULL
34616 };
34617
34618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34620 if (SWIG_arg_fail(1)) SWIG_fail;
34621 {
34622 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34623 if (SWIG_arg_fail(2)) SWIG_fail;
34624 }
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = (wxMenu *)(arg1)->Remove(arg2);
34628
34629 wxPyEndAllowThreads(__tstate);
34630 if (PyErr_Occurred()) SWIG_fail;
34631 }
34632 {
34633 resultobj = wxPyMake_wxObject(result, 0);
34634 }
34635 return resultobj;
34636 fail:
34637 return NULL;
34638 }
34639
34640
34641 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34642 PyObject *resultobj;
34643 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34644 size_t arg2 ;
34645 bool arg3 ;
34646 PyObject * obj0 = 0 ;
34647 PyObject * obj1 = 0 ;
34648 PyObject * obj2 = 0 ;
34649 char *kwnames[] = {
34650 (char *) "self",(char *) "pos",(char *) "enable", NULL
34651 };
34652
34653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34655 if (SWIG_arg_fail(1)) SWIG_fail;
34656 {
34657 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34658 if (SWIG_arg_fail(2)) SWIG_fail;
34659 }
34660 {
34661 arg3 = (bool)(SWIG_As_bool(obj2));
34662 if (SWIG_arg_fail(3)) SWIG_fail;
34663 }
34664 {
34665 PyThreadState* __tstate = wxPyBeginAllowThreads();
34666 (arg1)->EnableTop(arg2,arg3);
34667
34668 wxPyEndAllowThreads(__tstate);
34669 if (PyErr_Occurred()) SWIG_fail;
34670 }
34671 Py_INCREF(Py_None); resultobj = Py_None;
34672 return resultobj;
34673 fail:
34674 return NULL;
34675 }
34676
34677
34678 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34679 PyObject *resultobj;
34680 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34681 size_t arg2 ;
34682 bool result;
34683 PyObject * obj0 = 0 ;
34684 PyObject * obj1 = 0 ;
34685 char *kwnames[] = {
34686 (char *) "self",(char *) "pos", NULL
34687 };
34688
34689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34691 if (SWIG_arg_fail(1)) SWIG_fail;
34692 {
34693 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34694 if (SWIG_arg_fail(2)) SWIG_fail;
34695 }
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34699
34700 wxPyEndAllowThreads(__tstate);
34701 if (PyErr_Occurred()) SWIG_fail;
34702 }
34703 {
34704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34705 }
34706 return resultobj;
34707 fail:
34708 return NULL;
34709 }
34710
34711
34712 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34713 PyObject *resultobj;
34714 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34715 size_t arg2 ;
34716 wxString *arg3 = 0 ;
34717 bool temp3 = false ;
34718 PyObject * obj0 = 0 ;
34719 PyObject * obj1 = 0 ;
34720 PyObject * obj2 = 0 ;
34721 char *kwnames[] = {
34722 (char *) "self",(char *) "pos",(char *) "label", NULL
34723 };
34724
34725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34727 if (SWIG_arg_fail(1)) SWIG_fail;
34728 {
34729 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34730 if (SWIG_arg_fail(2)) SWIG_fail;
34731 }
34732 {
34733 arg3 = wxString_in_helper(obj2);
34734 if (arg3 == NULL) SWIG_fail;
34735 temp3 = true;
34736 }
34737 {
34738 PyThreadState* __tstate = wxPyBeginAllowThreads();
34739 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34740
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 Py_INCREF(Py_None); resultobj = Py_None;
34745 {
34746 if (temp3)
34747 delete arg3;
34748 }
34749 return resultobj;
34750 fail:
34751 {
34752 if (temp3)
34753 delete arg3;
34754 }
34755 return NULL;
34756 }
34757
34758
34759 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34760 PyObject *resultobj;
34761 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34762 size_t arg2 ;
34763 wxString result;
34764 PyObject * obj0 = 0 ;
34765 PyObject * obj1 = 0 ;
34766 char *kwnames[] = {
34767 (char *) "self",(char *) "pos", NULL
34768 };
34769
34770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34772 if (SWIG_arg_fail(1)) SWIG_fail;
34773 {
34774 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34775 if (SWIG_arg_fail(2)) SWIG_fail;
34776 }
34777 {
34778 PyThreadState* __tstate = wxPyBeginAllowThreads();
34779 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34780
34781 wxPyEndAllowThreads(__tstate);
34782 if (PyErr_Occurred()) SWIG_fail;
34783 }
34784 {
34785 #if wxUSE_UNICODE
34786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34787 #else
34788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34789 #endif
34790 }
34791 return resultobj;
34792 fail:
34793 return NULL;
34794 }
34795
34796
34797 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34798 PyObject *resultobj;
34799 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34800 wxString *arg2 = 0 ;
34801 wxString *arg3 = 0 ;
34802 int result;
34803 bool temp2 = false ;
34804 bool temp3 = false ;
34805 PyObject * obj0 = 0 ;
34806 PyObject * obj1 = 0 ;
34807 PyObject * obj2 = 0 ;
34808 char *kwnames[] = {
34809 (char *) "self",(char *) "menu",(char *) "item", NULL
34810 };
34811
34812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34814 if (SWIG_arg_fail(1)) SWIG_fail;
34815 {
34816 arg2 = wxString_in_helper(obj1);
34817 if (arg2 == NULL) SWIG_fail;
34818 temp2 = true;
34819 }
34820 {
34821 arg3 = wxString_in_helper(obj2);
34822 if (arg3 == NULL) SWIG_fail;
34823 temp3 = true;
34824 }
34825 {
34826 PyThreadState* __tstate = wxPyBeginAllowThreads();
34827 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34828
34829 wxPyEndAllowThreads(__tstate);
34830 if (PyErr_Occurred()) SWIG_fail;
34831 }
34832 {
34833 resultobj = SWIG_From_int((int)(result));
34834 }
34835 {
34836 if (temp2)
34837 delete arg2;
34838 }
34839 {
34840 if (temp3)
34841 delete arg3;
34842 }
34843 return resultobj;
34844 fail:
34845 {
34846 if (temp2)
34847 delete arg2;
34848 }
34849 {
34850 if (temp3)
34851 delete arg3;
34852 }
34853 return NULL;
34854 }
34855
34856
34857 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34858 PyObject *resultobj;
34859 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34860 int arg2 ;
34861 wxMenuItem *result;
34862 PyObject * obj0 = 0 ;
34863 PyObject * obj1 = 0 ;
34864 char *kwnames[] = {
34865 (char *) "self",(char *) "id", NULL
34866 };
34867
34868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34870 if (SWIG_arg_fail(1)) SWIG_fail;
34871 {
34872 arg2 = (int)(SWIG_As_int(obj1));
34873 if (SWIG_arg_fail(2)) SWIG_fail;
34874 }
34875 {
34876 PyThreadState* __tstate = wxPyBeginAllowThreads();
34877 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34878
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 {
34883 resultobj = wxPyMake_wxObject(result, 0);
34884 }
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj;
34893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34894 wxString *arg2 = 0 ;
34895 int result;
34896 bool temp2 = false ;
34897 PyObject * obj0 = 0 ;
34898 PyObject * obj1 = 0 ;
34899 char *kwnames[] = {
34900 (char *) "self",(char *) "title", NULL
34901 };
34902
34903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34905 if (SWIG_arg_fail(1)) SWIG_fail;
34906 {
34907 arg2 = wxString_in_helper(obj1);
34908 if (arg2 == NULL) SWIG_fail;
34909 temp2 = true;
34910 }
34911 {
34912 PyThreadState* __tstate = wxPyBeginAllowThreads();
34913 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34914
34915 wxPyEndAllowThreads(__tstate);
34916 if (PyErr_Occurred()) SWIG_fail;
34917 }
34918 {
34919 resultobj = SWIG_From_int((int)(result));
34920 }
34921 {
34922 if (temp2)
34923 delete arg2;
34924 }
34925 return resultobj;
34926 fail:
34927 {
34928 if (temp2)
34929 delete arg2;
34930 }
34931 return NULL;
34932 }
34933
34934
34935 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34936 PyObject *resultobj;
34937 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34938 int arg2 ;
34939 bool arg3 ;
34940 PyObject * obj0 = 0 ;
34941 PyObject * obj1 = 0 ;
34942 PyObject * obj2 = 0 ;
34943 char *kwnames[] = {
34944 (char *) "self",(char *) "id",(char *) "enable", NULL
34945 };
34946
34947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34949 if (SWIG_arg_fail(1)) SWIG_fail;
34950 {
34951 arg2 = (int)(SWIG_As_int(obj1));
34952 if (SWIG_arg_fail(2)) SWIG_fail;
34953 }
34954 {
34955 arg3 = (bool)(SWIG_As_bool(obj2));
34956 if (SWIG_arg_fail(3)) SWIG_fail;
34957 }
34958 {
34959 PyThreadState* __tstate = wxPyBeginAllowThreads();
34960 (arg1)->Enable(arg2,arg3);
34961
34962 wxPyEndAllowThreads(__tstate);
34963 if (PyErr_Occurred()) SWIG_fail;
34964 }
34965 Py_INCREF(Py_None); resultobj = Py_None;
34966 return resultobj;
34967 fail:
34968 return NULL;
34969 }
34970
34971
34972 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34973 PyObject *resultobj;
34974 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34975 int arg2 ;
34976 bool arg3 ;
34977 PyObject * obj0 = 0 ;
34978 PyObject * obj1 = 0 ;
34979 PyObject * obj2 = 0 ;
34980 char *kwnames[] = {
34981 (char *) "self",(char *) "id",(char *) "check", NULL
34982 };
34983
34984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34986 if (SWIG_arg_fail(1)) SWIG_fail;
34987 {
34988 arg2 = (int)(SWIG_As_int(obj1));
34989 if (SWIG_arg_fail(2)) SWIG_fail;
34990 }
34991 {
34992 arg3 = (bool)(SWIG_As_bool(obj2));
34993 if (SWIG_arg_fail(3)) SWIG_fail;
34994 }
34995 {
34996 PyThreadState* __tstate = wxPyBeginAllowThreads();
34997 (arg1)->Check(arg2,arg3);
34998
34999 wxPyEndAllowThreads(__tstate);
35000 if (PyErr_Occurred()) SWIG_fail;
35001 }
35002 Py_INCREF(Py_None); resultobj = Py_None;
35003 return resultobj;
35004 fail:
35005 return NULL;
35006 }
35007
35008
35009 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35010 PyObject *resultobj;
35011 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35012 int arg2 ;
35013 bool result;
35014 PyObject * obj0 = 0 ;
35015 PyObject * obj1 = 0 ;
35016 char *kwnames[] = {
35017 (char *) "self",(char *) "id", NULL
35018 };
35019
35020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35022 if (SWIG_arg_fail(1)) SWIG_fail;
35023 {
35024 arg2 = (int)(SWIG_As_int(obj1));
35025 if (SWIG_arg_fail(2)) SWIG_fail;
35026 }
35027 {
35028 PyThreadState* __tstate = wxPyBeginAllowThreads();
35029 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35030
35031 wxPyEndAllowThreads(__tstate);
35032 if (PyErr_Occurred()) SWIG_fail;
35033 }
35034 {
35035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35036 }
35037 return resultobj;
35038 fail:
35039 return NULL;
35040 }
35041
35042
35043 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35044 PyObject *resultobj;
35045 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35046 int arg2 ;
35047 bool result;
35048 PyObject * obj0 = 0 ;
35049 PyObject * obj1 = 0 ;
35050 char *kwnames[] = {
35051 (char *) "self",(char *) "id", NULL
35052 };
35053
35054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35056 if (SWIG_arg_fail(1)) SWIG_fail;
35057 {
35058 arg2 = (int)(SWIG_As_int(obj1));
35059 if (SWIG_arg_fail(2)) SWIG_fail;
35060 }
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35064
35065 wxPyEndAllowThreads(__tstate);
35066 if (PyErr_Occurred()) SWIG_fail;
35067 }
35068 {
35069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35070 }
35071 return resultobj;
35072 fail:
35073 return NULL;
35074 }
35075
35076
35077 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35078 PyObject *resultobj;
35079 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35080 int arg2 ;
35081 wxString *arg3 = 0 ;
35082 bool temp3 = false ;
35083 PyObject * obj0 = 0 ;
35084 PyObject * obj1 = 0 ;
35085 PyObject * obj2 = 0 ;
35086 char *kwnames[] = {
35087 (char *) "self",(char *) "id",(char *) "label", NULL
35088 };
35089
35090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35092 if (SWIG_arg_fail(1)) SWIG_fail;
35093 {
35094 arg2 = (int)(SWIG_As_int(obj1));
35095 if (SWIG_arg_fail(2)) SWIG_fail;
35096 }
35097 {
35098 arg3 = wxString_in_helper(obj2);
35099 if (arg3 == NULL) SWIG_fail;
35100 temp3 = true;
35101 }
35102 {
35103 PyThreadState* __tstate = wxPyBeginAllowThreads();
35104 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35105
35106 wxPyEndAllowThreads(__tstate);
35107 if (PyErr_Occurred()) SWIG_fail;
35108 }
35109 Py_INCREF(Py_None); resultobj = Py_None;
35110 {
35111 if (temp3)
35112 delete arg3;
35113 }
35114 return resultobj;
35115 fail:
35116 {
35117 if (temp3)
35118 delete arg3;
35119 }
35120 return NULL;
35121 }
35122
35123
35124 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35125 PyObject *resultobj;
35126 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35127 int arg2 ;
35128 wxString result;
35129 PyObject * obj0 = 0 ;
35130 PyObject * obj1 = 0 ;
35131 char *kwnames[] = {
35132 (char *) "self",(char *) "id", NULL
35133 };
35134
35135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35137 if (SWIG_arg_fail(1)) SWIG_fail;
35138 {
35139 arg2 = (int)(SWIG_As_int(obj1));
35140 if (SWIG_arg_fail(2)) SWIG_fail;
35141 }
35142 {
35143 PyThreadState* __tstate = wxPyBeginAllowThreads();
35144 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35145
35146 wxPyEndAllowThreads(__tstate);
35147 if (PyErr_Occurred()) SWIG_fail;
35148 }
35149 {
35150 #if wxUSE_UNICODE
35151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35152 #else
35153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35154 #endif
35155 }
35156 return resultobj;
35157 fail:
35158 return NULL;
35159 }
35160
35161
35162 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35163 PyObject *resultobj;
35164 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35165 int arg2 ;
35166 wxString *arg3 = 0 ;
35167 bool temp3 = false ;
35168 PyObject * obj0 = 0 ;
35169 PyObject * obj1 = 0 ;
35170 PyObject * obj2 = 0 ;
35171 char *kwnames[] = {
35172 (char *) "self",(char *) "id",(char *) "helpString", NULL
35173 };
35174
35175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35177 if (SWIG_arg_fail(1)) SWIG_fail;
35178 {
35179 arg2 = (int)(SWIG_As_int(obj1));
35180 if (SWIG_arg_fail(2)) SWIG_fail;
35181 }
35182 {
35183 arg3 = wxString_in_helper(obj2);
35184 if (arg3 == NULL) SWIG_fail;
35185 temp3 = true;
35186 }
35187 {
35188 PyThreadState* __tstate = wxPyBeginAllowThreads();
35189 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35190
35191 wxPyEndAllowThreads(__tstate);
35192 if (PyErr_Occurred()) SWIG_fail;
35193 }
35194 Py_INCREF(Py_None); resultobj = Py_None;
35195 {
35196 if (temp3)
35197 delete arg3;
35198 }
35199 return resultobj;
35200 fail:
35201 {
35202 if (temp3)
35203 delete arg3;
35204 }
35205 return NULL;
35206 }
35207
35208
35209 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35210 PyObject *resultobj;
35211 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35212 int arg2 ;
35213 wxString result;
35214 PyObject * obj0 = 0 ;
35215 PyObject * obj1 = 0 ;
35216 char *kwnames[] = {
35217 (char *) "self",(char *) "id", NULL
35218 };
35219
35220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35222 if (SWIG_arg_fail(1)) SWIG_fail;
35223 {
35224 arg2 = (int)(SWIG_As_int(obj1));
35225 if (SWIG_arg_fail(2)) SWIG_fail;
35226 }
35227 {
35228 PyThreadState* __tstate = wxPyBeginAllowThreads();
35229 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35230
35231 wxPyEndAllowThreads(__tstate);
35232 if (PyErr_Occurred()) SWIG_fail;
35233 }
35234 {
35235 #if wxUSE_UNICODE
35236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35237 #else
35238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35239 #endif
35240 }
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj;
35249 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35250 wxFrame *result;
35251 PyObject * obj0 = 0 ;
35252 char *kwnames[] = {
35253 (char *) "self", NULL
35254 };
35255
35256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35258 if (SWIG_arg_fail(1)) SWIG_fail;
35259 {
35260 PyThreadState* __tstate = wxPyBeginAllowThreads();
35261 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35262
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 {
35267 resultobj = wxPyMake_wxObject(result, 0);
35268 }
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35276 PyObject *resultobj;
35277 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35278 bool result;
35279 PyObject * obj0 = 0 ;
35280 char *kwnames[] = {
35281 (char *) "self", NULL
35282 };
35283
35284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35286 if (SWIG_arg_fail(1)) SWIG_fail;
35287 {
35288 PyThreadState* __tstate = wxPyBeginAllowThreads();
35289 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35290
35291 wxPyEndAllowThreads(__tstate);
35292 if (PyErr_Occurred()) SWIG_fail;
35293 }
35294 {
35295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35296 }
35297 return resultobj;
35298 fail:
35299 return NULL;
35300 }
35301
35302
35303 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35304 PyObject *resultobj;
35305 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35306 wxFrame *arg2 = (wxFrame *) 0 ;
35307 PyObject * obj0 = 0 ;
35308 PyObject * obj1 = 0 ;
35309 char *kwnames[] = {
35310 (char *) "self",(char *) "frame", NULL
35311 };
35312
35313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35315 if (SWIG_arg_fail(1)) SWIG_fail;
35316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35317 if (SWIG_arg_fail(2)) SWIG_fail;
35318 {
35319 PyThreadState* __tstate = wxPyBeginAllowThreads();
35320 (arg1)->Attach(arg2);
35321
35322 wxPyEndAllowThreads(__tstate);
35323 if (PyErr_Occurred()) SWIG_fail;
35324 }
35325 Py_INCREF(Py_None); resultobj = Py_None;
35326 return resultobj;
35327 fail:
35328 return NULL;
35329 }
35330
35331
35332 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35333 PyObject *resultobj;
35334 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35335 PyObject * obj0 = 0 ;
35336 char *kwnames[] = {
35337 (char *) "self", NULL
35338 };
35339
35340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35342 if (SWIG_arg_fail(1)) SWIG_fail;
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 (arg1)->Detach();
35346
35347 wxPyEndAllowThreads(__tstate);
35348 if (PyErr_Occurred()) SWIG_fail;
35349 }
35350 Py_INCREF(Py_None); resultobj = Py_None;
35351 return resultobj;
35352 fail:
35353 return NULL;
35354 }
35355
35356
35357 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35358 PyObject *obj;
35359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35360 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35361 Py_INCREF(obj);
35362 return Py_BuildValue((char *)"");
35363 }
35364 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35365 PyObject *resultobj;
35366 wxMenu *arg1 = (wxMenu *) NULL ;
35367 int arg2 = (int) wxID_ANY ;
35368 wxString const &arg3_defvalue = wxPyEmptyString ;
35369 wxString *arg3 = (wxString *) &arg3_defvalue ;
35370 wxString const &arg4_defvalue = wxPyEmptyString ;
35371 wxString *arg4 = (wxString *) &arg4_defvalue ;
35372 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35373 wxMenu *arg6 = (wxMenu *) NULL ;
35374 wxMenuItem *result;
35375 bool temp3 = false ;
35376 bool temp4 = false ;
35377 PyObject * obj0 = 0 ;
35378 PyObject * obj1 = 0 ;
35379 PyObject * obj2 = 0 ;
35380 PyObject * obj3 = 0 ;
35381 PyObject * obj4 = 0 ;
35382 PyObject * obj5 = 0 ;
35383 char *kwnames[] = {
35384 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35385 };
35386
35387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35388 if (obj0) {
35389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35390 if (SWIG_arg_fail(1)) SWIG_fail;
35391 }
35392 if (obj1) {
35393 {
35394 arg2 = (int)(SWIG_As_int(obj1));
35395 if (SWIG_arg_fail(2)) SWIG_fail;
35396 }
35397 }
35398 if (obj2) {
35399 {
35400 arg3 = wxString_in_helper(obj2);
35401 if (arg3 == NULL) SWIG_fail;
35402 temp3 = true;
35403 }
35404 }
35405 if (obj3) {
35406 {
35407 arg4 = wxString_in_helper(obj3);
35408 if (arg4 == NULL) SWIG_fail;
35409 temp4 = true;
35410 }
35411 }
35412 if (obj4) {
35413 {
35414 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35415 if (SWIG_arg_fail(5)) SWIG_fail;
35416 }
35417 }
35418 if (obj5) {
35419 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35420 if (SWIG_arg_fail(6)) SWIG_fail;
35421 }
35422 {
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35425
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 {
35430 resultobj = wxPyMake_wxObject(result, 1);
35431 }
35432 {
35433 if (temp3)
35434 delete arg3;
35435 }
35436 {
35437 if (temp4)
35438 delete arg4;
35439 }
35440 return resultobj;
35441 fail:
35442 {
35443 if (temp3)
35444 delete arg3;
35445 }
35446 {
35447 if (temp4)
35448 delete arg4;
35449 }
35450 return NULL;
35451 }
35452
35453
35454 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35455 PyObject *resultobj;
35456 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35457 wxMenu *result;
35458 PyObject * obj0 = 0 ;
35459 char *kwnames[] = {
35460 (char *) "self", NULL
35461 };
35462
35463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35465 if (SWIG_arg_fail(1)) SWIG_fail;
35466 {
35467 PyThreadState* __tstate = wxPyBeginAllowThreads();
35468 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35469
35470 wxPyEndAllowThreads(__tstate);
35471 if (PyErr_Occurred()) SWIG_fail;
35472 }
35473 {
35474 resultobj = wxPyMake_wxObject(result, 0);
35475 }
35476 return resultobj;
35477 fail:
35478 return NULL;
35479 }
35480
35481
35482 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35483 PyObject *resultobj;
35484 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35485 wxMenu *arg2 = (wxMenu *) 0 ;
35486 PyObject * obj0 = 0 ;
35487 PyObject * obj1 = 0 ;
35488 char *kwnames[] = {
35489 (char *) "self",(char *) "menu", NULL
35490 };
35491
35492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35494 if (SWIG_arg_fail(1)) SWIG_fail;
35495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35496 if (SWIG_arg_fail(2)) SWIG_fail;
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 (arg1)->SetMenu(arg2);
35500
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 Py_INCREF(Py_None); resultobj = Py_None;
35505 return resultobj;
35506 fail:
35507 return NULL;
35508 }
35509
35510
35511 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35512 PyObject *resultobj;
35513 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35514 int arg2 ;
35515 PyObject * obj0 = 0 ;
35516 PyObject * obj1 = 0 ;
35517 char *kwnames[] = {
35518 (char *) "self",(char *) "id", NULL
35519 };
35520
35521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35523 if (SWIG_arg_fail(1)) SWIG_fail;
35524 {
35525 arg2 = (int)(SWIG_As_int(obj1));
35526 if (SWIG_arg_fail(2)) SWIG_fail;
35527 }
35528 {
35529 PyThreadState* __tstate = wxPyBeginAllowThreads();
35530 (arg1)->SetId(arg2);
35531
35532 wxPyEndAllowThreads(__tstate);
35533 if (PyErr_Occurred()) SWIG_fail;
35534 }
35535 Py_INCREF(Py_None); resultobj = Py_None;
35536 return resultobj;
35537 fail:
35538 return NULL;
35539 }
35540
35541
35542 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35543 PyObject *resultobj;
35544 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35545 int result;
35546 PyObject * obj0 = 0 ;
35547 char *kwnames[] = {
35548 (char *) "self", NULL
35549 };
35550
35551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35553 if (SWIG_arg_fail(1)) SWIG_fail;
35554 {
35555 PyThreadState* __tstate = wxPyBeginAllowThreads();
35556 result = (int)((wxMenuItem const *)arg1)->GetId();
35557
35558 wxPyEndAllowThreads(__tstate);
35559 if (PyErr_Occurred()) SWIG_fail;
35560 }
35561 {
35562 resultobj = SWIG_From_int((int)(result));
35563 }
35564 return resultobj;
35565 fail:
35566 return NULL;
35567 }
35568
35569
35570 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35571 PyObject *resultobj;
35572 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35573 bool result;
35574 PyObject * obj0 = 0 ;
35575 char *kwnames[] = {
35576 (char *) "self", NULL
35577 };
35578
35579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35581 if (SWIG_arg_fail(1)) SWIG_fail;
35582 {
35583 PyThreadState* __tstate = wxPyBeginAllowThreads();
35584 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35585
35586 wxPyEndAllowThreads(__tstate);
35587 if (PyErr_Occurred()) SWIG_fail;
35588 }
35589 {
35590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35591 }
35592 return resultobj;
35593 fail:
35594 return NULL;
35595 }
35596
35597
35598 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35599 PyObject *resultobj;
35600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35601 wxString *arg2 = 0 ;
35602 bool temp2 = false ;
35603 PyObject * obj0 = 0 ;
35604 PyObject * obj1 = 0 ;
35605 char *kwnames[] = {
35606 (char *) "self",(char *) "str", NULL
35607 };
35608
35609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35611 if (SWIG_arg_fail(1)) SWIG_fail;
35612 {
35613 arg2 = wxString_in_helper(obj1);
35614 if (arg2 == NULL) SWIG_fail;
35615 temp2 = true;
35616 }
35617 {
35618 PyThreadState* __tstate = wxPyBeginAllowThreads();
35619 (arg1)->SetText((wxString const &)*arg2);
35620
35621 wxPyEndAllowThreads(__tstate);
35622 if (PyErr_Occurred()) SWIG_fail;
35623 }
35624 Py_INCREF(Py_None); resultobj = Py_None;
35625 {
35626 if (temp2)
35627 delete arg2;
35628 }
35629 return resultobj;
35630 fail:
35631 {
35632 if (temp2)
35633 delete arg2;
35634 }
35635 return NULL;
35636 }
35637
35638
35639 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35640 PyObject *resultobj;
35641 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35642 wxString result;
35643 PyObject * obj0 = 0 ;
35644 char *kwnames[] = {
35645 (char *) "self", NULL
35646 };
35647
35648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35650 if (SWIG_arg_fail(1)) SWIG_fail;
35651 {
35652 PyThreadState* __tstate = wxPyBeginAllowThreads();
35653 result = ((wxMenuItem const *)arg1)->GetLabel();
35654
35655 wxPyEndAllowThreads(__tstate);
35656 if (PyErr_Occurred()) SWIG_fail;
35657 }
35658 {
35659 #if wxUSE_UNICODE
35660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35661 #else
35662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35663 #endif
35664 }
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35672 PyObject *resultobj;
35673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35674 wxString *result;
35675 PyObject * obj0 = 0 ;
35676 char *kwnames[] = {
35677 (char *) "self", NULL
35678 };
35679
35680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35682 if (SWIG_arg_fail(1)) SWIG_fail;
35683 {
35684 PyThreadState* __tstate = wxPyBeginAllowThreads();
35685 {
35686 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35687 result = (wxString *) &_result_ref;
35688 }
35689
35690 wxPyEndAllowThreads(__tstate);
35691 if (PyErr_Occurred()) SWIG_fail;
35692 }
35693 {
35694 #if wxUSE_UNICODE
35695 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35696 #else
35697 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35698 #endif
35699 }
35700 return resultobj;
35701 fail:
35702 return NULL;
35703 }
35704
35705
35706 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35707 PyObject *resultobj;
35708 wxString *arg1 = 0 ;
35709 wxString result;
35710 bool temp1 = false ;
35711 PyObject * obj0 = 0 ;
35712 char *kwnames[] = {
35713 (char *) "text", NULL
35714 };
35715
35716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35717 {
35718 arg1 = wxString_in_helper(obj0);
35719 if (arg1 == NULL) SWIG_fail;
35720 temp1 = true;
35721 }
35722 {
35723 PyThreadState* __tstate = wxPyBeginAllowThreads();
35724 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35725
35726 wxPyEndAllowThreads(__tstate);
35727 if (PyErr_Occurred()) SWIG_fail;
35728 }
35729 {
35730 #if wxUSE_UNICODE
35731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35732 #else
35733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35734 #endif
35735 }
35736 {
35737 if (temp1)
35738 delete arg1;
35739 }
35740 return resultobj;
35741 fail:
35742 {
35743 if (temp1)
35744 delete arg1;
35745 }
35746 return NULL;
35747 }
35748
35749
35750 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35751 PyObject *resultobj;
35752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35753 wxItemKind result;
35754 PyObject * obj0 = 0 ;
35755 char *kwnames[] = {
35756 (char *) "self", NULL
35757 };
35758
35759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35761 if (SWIG_arg_fail(1)) SWIG_fail;
35762 {
35763 PyThreadState* __tstate = wxPyBeginAllowThreads();
35764 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35765
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 resultobj = SWIG_From_int((result));
35770 return resultobj;
35771 fail:
35772 return NULL;
35773 }
35774
35775
35776 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35777 PyObject *resultobj;
35778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35779 wxItemKind arg2 ;
35780 PyObject * obj0 = 0 ;
35781 PyObject * obj1 = 0 ;
35782 char *kwnames[] = {
35783 (char *) "self",(char *) "kind", NULL
35784 };
35785
35786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35788 if (SWIG_arg_fail(1)) SWIG_fail;
35789 {
35790 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35791 if (SWIG_arg_fail(2)) SWIG_fail;
35792 }
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 (arg1)->SetKind((wxItemKind )arg2);
35796
35797 wxPyEndAllowThreads(__tstate);
35798 if (PyErr_Occurred()) SWIG_fail;
35799 }
35800 Py_INCREF(Py_None); resultobj = Py_None;
35801 return resultobj;
35802 fail:
35803 return NULL;
35804 }
35805
35806
35807 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35808 PyObject *resultobj;
35809 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35810 bool arg2 ;
35811 PyObject * obj0 = 0 ;
35812 PyObject * obj1 = 0 ;
35813 char *kwnames[] = {
35814 (char *) "self",(char *) "checkable", NULL
35815 };
35816
35817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35819 if (SWIG_arg_fail(1)) SWIG_fail;
35820 {
35821 arg2 = (bool)(SWIG_As_bool(obj1));
35822 if (SWIG_arg_fail(2)) SWIG_fail;
35823 }
35824 {
35825 PyThreadState* __tstate = wxPyBeginAllowThreads();
35826 (arg1)->SetCheckable(arg2);
35827
35828 wxPyEndAllowThreads(__tstate);
35829 if (PyErr_Occurred()) SWIG_fail;
35830 }
35831 Py_INCREF(Py_None); resultobj = Py_None;
35832 return resultobj;
35833 fail:
35834 return NULL;
35835 }
35836
35837
35838 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35839 PyObject *resultobj;
35840 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35841 bool result;
35842 PyObject * obj0 = 0 ;
35843 char *kwnames[] = {
35844 (char *) "self", NULL
35845 };
35846
35847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35849 if (SWIG_arg_fail(1)) SWIG_fail;
35850 {
35851 PyThreadState* __tstate = wxPyBeginAllowThreads();
35852 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35853
35854 wxPyEndAllowThreads(__tstate);
35855 if (PyErr_Occurred()) SWIG_fail;
35856 }
35857 {
35858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35859 }
35860 return resultobj;
35861 fail:
35862 return NULL;
35863 }
35864
35865
35866 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35867 PyObject *resultobj;
35868 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35869 bool result;
35870 PyObject * obj0 = 0 ;
35871 char *kwnames[] = {
35872 (char *) "self", NULL
35873 };
35874
35875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35877 if (SWIG_arg_fail(1)) SWIG_fail;
35878 {
35879 PyThreadState* __tstate = wxPyBeginAllowThreads();
35880 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35881
35882 wxPyEndAllowThreads(__tstate);
35883 if (PyErr_Occurred()) SWIG_fail;
35884 }
35885 {
35886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35887 }
35888 return resultobj;
35889 fail:
35890 return NULL;
35891 }
35892
35893
35894 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35895 PyObject *resultobj;
35896 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35897 wxMenu *arg2 = (wxMenu *) 0 ;
35898 PyObject * obj0 = 0 ;
35899 PyObject * obj1 = 0 ;
35900 char *kwnames[] = {
35901 (char *) "self",(char *) "menu", NULL
35902 };
35903
35904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35906 if (SWIG_arg_fail(1)) SWIG_fail;
35907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35908 if (SWIG_arg_fail(2)) SWIG_fail;
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 (arg1)->SetSubMenu(arg2);
35912
35913 wxPyEndAllowThreads(__tstate);
35914 if (PyErr_Occurred()) SWIG_fail;
35915 }
35916 Py_INCREF(Py_None); resultobj = Py_None;
35917 return resultobj;
35918 fail:
35919 return NULL;
35920 }
35921
35922
35923 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35924 PyObject *resultobj;
35925 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35926 wxMenu *result;
35927 PyObject * obj0 = 0 ;
35928 char *kwnames[] = {
35929 (char *) "self", NULL
35930 };
35931
35932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35934 if (SWIG_arg_fail(1)) SWIG_fail;
35935 {
35936 PyThreadState* __tstate = wxPyBeginAllowThreads();
35937 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35938
35939 wxPyEndAllowThreads(__tstate);
35940 if (PyErr_Occurred()) SWIG_fail;
35941 }
35942 {
35943 resultobj = wxPyMake_wxObject(result, 0);
35944 }
35945 return resultobj;
35946 fail:
35947 return NULL;
35948 }
35949
35950
35951 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35952 PyObject *resultobj;
35953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35954 bool arg2 = (bool) true ;
35955 PyObject * obj0 = 0 ;
35956 PyObject * obj1 = 0 ;
35957 char *kwnames[] = {
35958 (char *) "self",(char *) "enable", NULL
35959 };
35960
35961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35963 if (SWIG_arg_fail(1)) SWIG_fail;
35964 if (obj1) {
35965 {
35966 arg2 = (bool)(SWIG_As_bool(obj1));
35967 if (SWIG_arg_fail(2)) SWIG_fail;
35968 }
35969 }
35970 {
35971 PyThreadState* __tstate = wxPyBeginAllowThreads();
35972 (arg1)->Enable(arg2);
35973
35974 wxPyEndAllowThreads(__tstate);
35975 if (PyErr_Occurred()) SWIG_fail;
35976 }
35977 Py_INCREF(Py_None); resultobj = Py_None;
35978 return resultobj;
35979 fail:
35980 return NULL;
35981 }
35982
35983
35984 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35985 PyObject *resultobj;
35986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35987 bool result;
35988 PyObject * obj0 = 0 ;
35989 char *kwnames[] = {
35990 (char *) "self", NULL
35991 };
35992
35993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35995 if (SWIG_arg_fail(1)) SWIG_fail;
35996 {
35997 PyThreadState* __tstate = wxPyBeginAllowThreads();
35998 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35999
36000 wxPyEndAllowThreads(__tstate);
36001 if (PyErr_Occurred()) SWIG_fail;
36002 }
36003 {
36004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36005 }
36006 return resultobj;
36007 fail:
36008 return NULL;
36009 }
36010
36011
36012 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36013 PyObject *resultobj;
36014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36015 bool arg2 = (bool) true ;
36016 PyObject * obj0 = 0 ;
36017 PyObject * obj1 = 0 ;
36018 char *kwnames[] = {
36019 (char *) "self",(char *) "check", NULL
36020 };
36021
36022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36024 if (SWIG_arg_fail(1)) SWIG_fail;
36025 if (obj1) {
36026 {
36027 arg2 = (bool)(SWIG_As_bool(obj1));
36028 if (SWIG_arg_fail(2)) SWIG_fail;
36029 }
36030 }
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 (arg1)->Check(arg2);
36034
36035 wxPyEndAllowThreads(__tstate);
36036 if (PyErr_Occurred()) SWIG_fail;
36037 }
36038 Py_INCREF(Py_None); resultobj = Py_None;
36039 return resultobj;
36040 fail:
36041 return NULL;
36042 }
36043
36044
36045 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36046 PyObject *resultobj;
36047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36048 bool result;
36049 PyObject * obj0 = 0 ;
36050 char *kwnames[] = {
36051 (char *) "self", NULL
36052 };
36053
36054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36056 if (SWIG_arg_fail(1)) SWIG_fail;
36057 {
36058 PyThreadState* __tstate = wxPyBeginAllowThreads();
36059 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36060
36061 wxPyEndAllowThreads(__tstate);
36062 if (PyErr_Occurred()) SWIG_fail;
36063 }
36064 {
36065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36066 }
36067 return resultobj;
36068 fail:
36069 return NULL;
36070 }
36071
36072
36073 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36074 PyObject *resultobj;
36075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36076 PyObject * obj0 = 0 ;
36077 char *kwnames[] = {
36078 (char *) "self", NULL
36079 };
36080
36081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36083 if (SWIG_arg_fail(1)) SWIG_fail;
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 (arg1)->Toggle();
36087
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 Py_INCREF(Py_None); resultobj = Py_None;
36092 return resultobj;
36093 fail:
36094 return NULL;
36095 }
36096
36097
36098 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36099 PyObject *resultobj;
36100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36101 wxString *arg2 = 0 ;
36102 bool temp2 = false ;
36103 PyObject * obj0 = 0 ;
36104 PyObject * obj1 = 0 ;
36105 char *kwnames[] = {
36106 (char *) "self",(char *) "str", NULL
36107 };
36108
36109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36111 if (SWIG_arg_fail(1)) SWIG_fail;
36112 {
36113 arg2 = wxString_in_helper(obj1);
36114 if (arg2 == NULL) SWIG_fail;
36115 temp2 = true;
36116 }
36117 {
36118 PyThreadState* __tstate = wxPyBeginAllowThreads();
36119 (arg1)->SetHelp((wxString const &)*arg2);
36120
36121 wxPyEndAllowThreads(__tstate);
36122 if (PyErr_Occurred()) SWIG_fail;
36123 }
36124 Py_INCREF(Py_None); resultobj = Py_None;
36125 {
36126 if (temp2)
36127 delete arg2;
36128 }
36129 return resultobj;
36130 fail:
36131 {
36132 if (temp2)
36133 delete arg2;
36134 }
36135 return NULL;
36136 }
36137
36138
36139 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36140 PyObject *resultobj;
36141 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36142 wxString *result;
36143 PyObject * obj0 = 0 ;
36144 char *kwnames[] = {
36145 (char *) "self", NULL
36146 };
36147
36148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36150 if (SWIG_arg_fail(1)) SWIG_fail;
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 {
36154 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36155 result = (wxString *) &_result_ref;
36156 }
36157
36158 wxPyEndAllowThreads(__tstate);
36159 if (PyErr_Occurred()) SWIG_fail;
36160 }
36161 {
36162 #if wxUSE_UNICODE
36163 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36164 #else
36165 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36166 #endif
36167 }
36168 return resultobj;
36169 fail:
36170 return NULL;
36171 }
36172
36173
36174 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36175 PyObject *resultobj;
36176 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36177 wxAcceleratorEntry *result;
36178 PyObject * obj0 = 0 ;
36179 char *kwnames[] = {
36180 (char *) "self", NULL
36181 };
36182
36183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36185 if (SWIG_arg_fail(1)) SWIG_fail;
36186 {
36187 PyThreadState* __tstate = wxPyBeginAllowThreads();
36188 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36189
36190 wxPyEndAllowThreads(__tstate);
36191 if (PyErr_Occurred()) SWIG_fail;
36192 }
36193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36194 return resultobj;
36195 fail:
36196 return NULL;
36197 }
36198
36199
36200 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36201 PyObject *resultobj;
36202 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36203 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36204 PyObject * obj0 = 0 ;
36205 PyObject * obj1 = 0 ;
36206 char *kwnames[] = {
36207 (char *) "self",(char *) "accel", NULL
36208 };
36209
36210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36212 if (SWIG_arg_fail(1)) SWIG_fail;
36213 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36214 if (SWIG_arg_fail(2)) SWIG_fail;
36215 {
36216 PyThreadState* __tstate = wxPyBeginAllowThreads();
36217 (arg1)->SetAccel(arg2);
36218
36219 wxPyEndAllowThreads(__tstate);
36220 if (PyErr_Occurred()) SWIG_fail;
36221 }
36222 Py_INCREF(Py_None); resultobj = Py_None;
36223 return resultobj;
36224 fail:
36225 return NULL;
36226 }
36227
36228
36229 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36230 PyObject *resultobj;
36231 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36232 wxFont *arg2 = 0 ;
36233 PyObject * obj0 = 0 ;
36234 PyObject * obj1 = 0 ;
36235 char *kwnames[] = {
36236 (char *) "self",(char *) "font", NULL
36237 };
36238
36239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36241 if (SWIG_arg_fail(1)) SWIG_fail;
36242 {
36243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36244 if (SWIG_arg_fail(2)) SWIG_fail;
36245 if (arg2 == NULL) {
36246 SWIG_null_ref("wxFont");
36247 }
36248 if (SWIG_arg_fail(2)) SWIG_fail;
36249 }
36250 {
36251 PyThreadState* __tstate = wxPyBeginAllowThreads();
36252 (arg1)->SetFont((wxFont const &)*arg2);
36253
36254 wxPyEndAllowThreads(__tstate);
36255 if (PyErr_Occurred()) SWIG_fail;
36256 }
36257 Py_INCREF(Py_None); resultobj = Py_None;
36258 return resultobj;
36259 fail:
36260 return NULL;
36261 }
36262
36263
36264 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36265 PyObject *resultobj;
36266 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36267 wxFont result;
36268 PyObject * obj0 = 0 ;
36269 char *kwnames[] = {
36270 (char *) "self", NULL
36271 };
36272
36273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36275 if (SWIG_arg_fail(1)) SWIG_fail;
36276 {
36277 PyThreadState* __tstate = wxPyBeginAllowThreads();
36278 result = (arg1)->GetFont();
36279
36280 wxPyEndAllowThreads(__tstate);
36281 if (PyErr_Occurred()) SWIG_fail;
36282 }
36283 {
36284 wxFont * resultptr;
36285 resultptr = new wxFont((wxFont &)(result));
36286 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36287 }
36288 return resultobj;
36289 fail:
36290 return NULL;
36291 }
36292
36293
36294 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36295 PyObject *resultobj;
36296 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36297 wxColour *arg2 = 0 ;
36298 wxColour temp2 ;
36299 PyObject * obj0 = 0 ;
36300 PyObject * obj1 = 0 ;
36301 char *kwnames[] = {
36302 (char *) "self",(char *) "colText", NULL
36303 };
36304
36305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36307 if (SWIG_arg_fail(1)) SWIG_fail;
36308 {
36309 arg2 = &temp2;
36310 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36311 }
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 (arg1)->SetTextColour((wxColour const &)*arg2);
36315
36316 wxPyEndAllowThreads(__tstate);
36317 if (PyErr_Occurred()) SWIG_fail;
36318 }
36319 Py_INCREF(Py_None); resultobj = Py_None;
36320 return resultobj;
36321 fail:
36322 return NULL;
36323 }
36324
36325
36326 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36327 PyObject *resultobj;
36328 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36329 wxColour result;
36330 PyObject * obj0 = 0 ;
36331 char *kwnames[] = {
36332 (char *) "self", NULL
36333 };
36334
36335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36337 if (SWIG_arg_fail(1)) SWIG_fail;
36338 {
36339 PyThreadState* __tstate = wxPyBeginAllowThreads();
36340 result = (arg1)->GetTextColour();
36341
36342 wxPyEndAllowThreads(__tstate);
36343 if (PyErr_Occurred()) SWIG_fail;
36344 }
36345 {
36346 wxColour * resultptr;
36347 resultptr = new wxColour((wxColour &)(result));
36348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36349 }
36350 return resultobj;
36351 fail:
36352 return NULL;
36353 }
36354
36355
36356 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36357 PyObject *resultobj;
36358 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36359 wxColour *arg2 = 0 ;
36360 wxColour temp2 ;
36361 PyObject * obj0 = 0 ;
36362 PyObject * obj1 = 0 ;
36363 char *kwnames[] = {
36364 (char *) "self",(char *) "colBack", NULL
36365 };
36366
36367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36369 if (SWIG_arg_fail(1)) SWIG_fail;
36370 {
36371 arg2 = &temp2;
36372 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36373 }
36374 {
36375 PyThreadState* __tstate = wxPyBeginAllowThreads();
36376 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36377
36378 wxPyEndAllowThreads(__tstate);
36379 if (PyErr_Occurred()) SWIG_fail;
36380 }
36381 Py_INCREF(Py_None); resultobj = Py_None;
36382 return resultobj;
36383 fail:
36384 return NULL;
36385 }
36386
36387
36388 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36389 PyObject *resultobj;
36390 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36391 wxColour result;
36392 PyObject * obj0 = 0 ;
36393 char *kwnames[] = {
36394 (char *) "self", NULL
36395 };
36396
36397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36399 if (SWIG_arg_fail(1)) SWIG_fail;
36400 {
36401 PyThreadState* __tstate = wxPyBeginAllowThreads();
36402 result = (arg1)->GetBackgroundColour();
36403
36404 wxPyEndAllowThreads(__tstate);
36405 if (PyErr_Occurred()) SWIG_fail;
36406 }
36407 {
36408 wxColour * resultptr;
36409 resultptr = new wxColour((wxColour &)(result));
36410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36411 }
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj;
36420 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36421 wxBitmap *arg2 = 0 ;
36422 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36423 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36424 PyObject * obj0 = 0 ;
36425 PyObject * obj1 = 0 ;
36426 PyObject * obj2 = 0 ;
36427 char *kwnames[] = {
36428 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36429 };
36430
36431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36433 if (SWIG_arg_fail(1)) SWIG_fail;
36434 {
36435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36436 if (SWIG_arg_fail(2)) SWIG_fail;
36437 if (arg2 == NULL) {
36438 SWIG_null_ref("wxBitmap");
36439 }
36440 if (SWIG_arg_fail(2)) SWIG_fail;
36441 }
36442 if (obj2) {
36443 {
36444 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36445 if (SWIG_arg_fail(3)) SWIG_fail;
36446 if (arg3 == NULL) {
36447 SWIG_null_ref("wxBitmap");
36448 }
36449 if (SWIG_arg_fail(3)) SWIG_fail;
36450 }
36451 }
36452 {
36453 PyThreadState* __tstate = wxPyBeginAllowThreads();
36454 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36455
36456 wxPyEndAllowThreads(__tstate);
36457 if (PyErr_Occurred()) SWIG_fail;
36458 }
36459 Py_INCREF(Py_None); resultobj = Py_None;
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36467 PyObject *resultobj;
36468 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36469 wxBitmap *arg2 = 0 ;
36470 PyObject * obj0 = 0 ;
36471 PyObject * obj1 = 0 ;
36472 char *kwnames[] = {
36473 (char *) "self",(char *) "bmpDisabled", NULL
36474 };
36475
36476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36478 if (SWIG_arg_fail(1)) SWIG_fail;
36479 {
36480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36481 if (SWIG_arg_fail(2)) SWIG_fail;
36482 if (arg2 == NULL) {
36483 SWIG_null_ref("wxBitmap");
36484 }
36485 if (SWIG_arg_fail(2)) SWIG_fail;
36486 }
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36490
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 Py_INCREF(Py_None); resultobj = Py_None;
36495 return resultobj;
36496 fail:
36497 return NULL;
36498 }
36499
36500
36501 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36502 PyObject *resultobj;
36503 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36504 wxBitmap *result;
36505 PyObject * obj0 = 0 ;
36506 char *kwnames[] = {
36507 (char *) "self", NULL
36508 };
36509
36510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36512 if (SWIG_arg_fail(1)) SWIG_fail;
36513 {
36514 PyThreadState* __tstate = wxPyBeginAllowThreads();
36515 {
36516 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36517 result = (wxBitmap *) &_result_ref;
36518 }
36519
36520 wxPyEndAllowThreads(__tstate);
36521 if (PyErr_Occurred()) SWIG_fail;
36522 }
36523 {
36524 wxBitmap* resultptr = new wxBitmap(*result);
36525 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36526 }
36527 return resultobj;
36528 fail:
36529 return NULL;
36530 }
36531
36532
36533 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36534 PyObject *resultobj;
36535 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36536 int arg2 ;
36537 PyObject * obj0 = 0 ;
36538 PyObject * obj1 = 0 ;
36539 char *kwnames[] = {
36540 (char *) "self",(char *) "nWidth", NULL
36541 };
36542
36543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36545 if (SWIG_arg_fail(1)) SWIG_fail;
36546 {
36547 arg2 = (int)(SWIG_As_int(obj1));
36548 if (SWIG_arg_fail(2)) SWIG_fail;
36549 }
36550 {
36551 PyThreadState* __tstate = wxPyBeginAllowThreads();
36552 (arg1)->SetMarginWidth(arg2);
36553
36554 wxPyEndAllowThreads(__tstate);
36555 if (PyErr_Occurred()) SWIG_fail;
36556 }
36557 Py_INCREF(Py_None); resultobj = Py_None;
36558 return resultobj;
36559 fail:
36560 return NULL;
36561 }
36562
36563
36564 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36565 PyObject *resultobj;
36566 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36567 int result;
36568 PyObject * obj0 = 0 ;
36569 char *kwnames[] = {
36570 (char *) "self", NULL
36571 };
36572
36573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36575 if (SWIG_arg_fail(1)) SWIG_fail;
36576 {
36577 PyThreadState* __tstate = wxPyBeginAllowThreads();
36578 result = (int)(arg1)->GetMarginWidth();
36579
36580 wxPyEndAllowThreads(__tstate);
36581 if (PyErr_Occurred()) SWIG_fail;
36582 }
36583 {
36584 resultobj = SWIG_From_int((int)(result));
36585 }
36586 return resultobj;
36587 fail:
36588 return NULL;
36589 }
36590
36591
36592 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36593 PyObject *resultobj;
36594 int result;
36595 char *kwnames[] = {
36596 NULL
36597 };
36598
36599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36600 {
36601 PyThreadState* __tstate = wxPyBeginAllowThreads();
36602 result = (int)wxMenuItem::GetDefaultMarginWidth();
36603
36604 wxPyEndAllowThreads(__tstate);
36605 if (PyErr_Occurred()) SWIG_fail;
36606 }
36607 {
36608 resultobj = SWIG_From_int((int)(result));
36609 }
36610 return resultobj;
36611 fail:
36612 return NULL;
36613 }
36614
36615
36616 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36617 PyObject *resultobj;
36618 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36619 bool result;
36620 PyObject * obj0 = 0 ;
36621 char *kwnames[] = {
36622 (char *) "self", NULL
36623 };
36624
36625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36627 if (SWIG_arg_fail(1)) SWIG_fail;
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 result = (bool)(arg1)->IsOwnerDrawn();
36631
36632 wxPyEndAllowThreads(__tstate);
36633 if (PyErr_Occurred()) SWIG_fail;
36634 }
36635 {
36636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36637 }
36638 return resultobj;
36639 fail:
36640 return NULL;
36641 }
36642
36643
36644 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36645 PyObject *resultobj;
36646 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36647 bool arg2 = (bool) true ;
36648 PyObject * obj0 = 0 ;
36649 PyObject * obj1 = 0 ;
36650 char *kwnames[] = {
36651 (char *) "self",(char *) "ownerDrawn", NULL
36652 };
36653
36654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36656 if (SWIG_arg_fail(1)) SWIG_fail;
36657 if (obj1) {
36658 {
36659 arg2 = (bool)(SWIG_As_bool(obj1));
36660 if (SWIG_arg_fail(2)) SWIG_fail;
36661 }
36662 }
36663 {
36664 PyThreadState* __tstate = wxPyBeginAllowThreads();
36665 (arg1)->SetOwnerDrawn(arg2);
36666
36667 wxPyEndAllowThreads(__tstate);
36668 if (PyErr_Occurred()) SWIG_fail;
36669 }
36670 Py_INCREF(Py_None); resultobj = Py_None;
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36678 PyObject *resultobj;
36679 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36680 PyObject * obj0 = 0 ;
36681 char *kwnames[] = {
36682 (char *) "self", NULL
36683 };
36684
36685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36687 if (SWIG_arg_fail(1)) SWIG_fail;
36688 {
36689 PyThreadState* __tstate = wxPyBeginAllowThreads();
36690 (arg1)->ResetOwnerDrawn();
36691
36692 wxPyEndAllowThreads(__tstate);
36693 if (PyErr_Occurred()) SWIG_fail;
36694 }
36695 Py_INCREF(Py_None); resultobj = Py_None;
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36703 PyObject *resultobj;
36704 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36705 wxBitmap *arg2 = 0 ;
36706 PyObject * obj0 = 0 ;
36707 PyObject * obj1 = 0 ;
36708 char *kwnames[] = {
36709 (char *) "self",(char *) "bitmap", NULL
36710 };
36711
36712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36714 if (SWIG_arg_fail(1)) SWIG_fail;
36715 {
36716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36717 if (SWIG_arg_fail(2)) SWIG_fail;
36718 if (arg2 == NULL) {
36719 SWIG_null_ref("wxBitmap");
36720 }
36721 if (SWIG_arg_fail(2)) SWIG_fail;
36722 }
36723 {
36724 PyThreadState* __tstate = wxPyBeginAllowThreads();
36725 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36726
36727 wxPyEndAllowThreads(__tstate);
36728 if (PyErr_Occurred()) SWIG_fail;
36729 }
36730 Py_INCREF(Py_None); resultobj = Py_None;
36731 return resultobj;
36732 fail:
36733 return NULL;
36734 }
36735
36736
36737 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36738 PyObject *resultobj;
36739 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36740 wxBitmap *result;
36741 PyObject * obj0 = 0 ;
36742 char *kwnames[] = {
36743 (char *) "self", NULL
36744 };
36745
36746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36748 if (SWIG_arg_fail(1)) SWIG_fail;
36749 {
36750 PyThreadState* __tstate = wxPyBeginAllowThreads();
36751 {
36752 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36753 result = (wxBitmap *) &_result_ref;
36754 }
36755
36756 wxPyEndAllowThreads(__tstate);
36757 if (PyErr_Occurred()) SWIG_fail;
36758 }
36759 {
36760 wxBitmap* resultptr = new wxBitmap(*result);
36761 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36762 }
36763 return resultobj;
36764 fail:
36765 return NULL;
36766 }
36767
36768
36769 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36770 PyObject *obj;
36771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36772 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36773 Py_INCREF(obj);
36774 return Py_BuildValue((char *)"");
36775 }
36776 static int _wrap_ControlNameStr_set(PyObject *) {
36777 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36778 return 1;
36779 }
36780
36781
36782 static PyObject *_wrap_ControlNameStr_get(void) {
36783 PyObject *pyobj;
36784
36785 {
36786 #if wxUSE_UNICODE
36787 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36788 #else
36789 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36790 #endif
36791 }
36792 return pyobj;
36793 }
36794
36795
36796 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36797 PyObject *resultobj;
36798 wxWindow *arg1 = (wxWindow *) 0 ;
36799 int arg2 = (int) -1 ;
36800 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36801 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36802 wxSize const &arg4_defvalue = wxDefaultSize ;
36803 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36804 long arg5 = (long) 0 ;
36805 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36806 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36807 wxString const &arg7_defvalue = wxPyControlNameStr ;
36808 wxString *arg7 = (wxString *) &arg7_defvalue ;
36809 wxControl *result;
36810 wxPoint temp3 ;
36811 wxSize temp4 ;
36812 bool temp7 = false ;
36813 PyObject * obj0 = 0 ;
36814 PyObject * obj1 = 0 ;
36815 PyObject * obj2 = 0 ;
36816 PyObject * obj3 = 0 ;
36817 PyObject * obj4 = 0 ;
36818 PyObject * obj5 = 0 ;
36819 PyObject * obj6 = 0 ;
36820 char *kwnames[] = {
36821 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36822 };
36823
36824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36826 if (SWIG_arg_fail(1)) SWIG_fail;
36827 if (obj1) {
36828 {
36829 arg2 = (int)(SWIG_As_int(obj1));
36830 if (SWIG_arg_fail(2)) SWIG_fail;
36831 }
36832 }
36833 if (obj2) {
36834 {
36835 arg3 = &temp3;
36836 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36837 }
36838 }
36839 if (obj3) {
36840 {
36841 arg4 = &temp4;
36842 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36843 }
36844 }
36845 if (obj4) {
36846 {
36847 arg5 = (long)(SWIG_As_long(obj4));
36848 if (SWIG_arg_fail(5)) SWIG_fail;
36849 }
36850 }
36851 if (obj5) {
36852 {
36853 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36854 if (SWIG_arg_fail(6)) SWIG_fail;
36855 if (arg6 == NULL) {
36856 SWIG_null_ref("wxValidator");
36857 }
36858 if (SWIG_arg_fail(6)) SWIG_fail;
36859 }
36860 }
36861 if (obj6) {
36862 {
36863 arg7 = wxString_in_helper(obj6);
36864 if (arg7 == NULL) SWIG_fail;
36865 temp7 = true;
36866 }
36867 }
36868 {
36869 if (!wxPyCheckForApp()) SWIG_fail;
36870 PyThreadState* __tstate = wxPyBeginAllowThreads();
36871 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36872
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36877 {
36878 if (temp7)
36879 delete arg7;
36880 }
36881 return resultobj;
36882 fail:
36883 {
36884 if (temp7)
36885 delete arg7;
36886 }
36887 return NULL;
36888 }
36889
36890
36891 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36892 PyObject *resultobj;
36893 wxControl *result;
36894 char *kwnames[] = {
36895 NULL
36896 };
36897
36898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36899 {
36900 if (!wxPyCheckForApp()) SWIG_fail;
36901 PyThreadState* __tstate = wxPyBeginAllowThreads();
36902 result = (wxControl *)new wxControl();
36903
36904 wxPyEndAllowThreads(__tstate);
36905 if (PyErr_Occurred()) SWIG_fail;
36906 }
36907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36908 return resultobj;
36909 fail:
36910 return NULL;
36911 }
36912
36913
36914 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36915 PyObject *resultobj;
36916 wxControl *arg1 = (wxControl *) 0 ;
36917 wxWindow *arg2 = (wxWindow *) 0 ;
36918 int arg3 = (int) -1 ;
36919 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36920 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36921 wxSize const &arg5_defvalue = wxDefaultSize ;
36922 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36923 long arg6 = (long) 0 ;
36924 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36925 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36926 wxString const &arg8_defvalue = wxPyControlNameStr ;
36927 wxString *arg8 = (wxString *) &arg8_defvalue ;
36928 bool result;
36929 wxPoint temp4 ;
36930 wxSize temp5 ;
36931 bool temp8 = false ;
36932 PyObject * obj0 = 0 ;
36933 PyObject * obj1 = 0 ;
36934 PyObject * obj2 = 0 ;
36935 PyObject * obj3 = 0 ;
36936 PyObject * obj4 = 0 ;
36937 PyObject * obj5 = 0 ;
36938 PyObject * obj6 = 0 ;
36939 PyObject * obj7 = 0 ;
36940 char *kwnames[] = {
36941 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36942 };
36943
36944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36946 if (SWIG_arg_fail(1)) SWIG_fail;
36947 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36948 if (SWIG_arg_fail(2)) SWIG_fail;
36949 if (obj2) {
36950 {
36951 arg3 = (int)(SWIG_As_int(obj2));
36952 if (SWIG_arg_fail(3)) SWIG_fail;
36953 }
36954 }
36955 if (obj3) {
36956 {
36957 arg4 = &temp4;
36958 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36959 }
36960 }
36961 if (obj4) {
36962 {
36963 arg5 = &temp5;
36964 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36965 }
36966 }
36967 if (obj5) {
36968 {
36969 arg6 = (long)(SWIG_As_long(obj5));
36970 if (SWIG_arg_fail(6)) SWIG_fail;
36971 }
36972 }
36973 if (obj6) {
36974 {
36975 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36976 if (SWIG_arg_fail(7)) SWIG_fail;
36977 if (arg7 == NULL) {
36978 SWIG_null_ref("wxValidator");
36979 }
36980 if (SWIG_arg_fail(7)) SWIG_fail;
36981 }
36982 }
36983 if (obj7) {
36984 {
36985 arg8 = wxString_in_helper(obj7);
36986 if (arg8 == NULL) SWIG_fail;
36987 temp8 = true;
36988 }
36989 }
36990 {
36991 PyThreadState* __tstate = wxPyBeginAllowThreads();
36992 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36993
36994 wxPyEndAllowThreads(__tstate);
36995 if (PyErr_Occurred()) SWIG_fail;
36996 }
36997 {
36998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36999 }
37000 {
37001 if (temp8)
37002 delete arg8;
37003 }
37004 return resultobj;
37005 fail:
37006 {
37007 if (temp8)
37008 delete arg8;
37009 }
37010 return NULL;
37011 }
37012
37013
37014 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37015 PyObject *resultobj;
37016 wxControl *arg1 = (wxControl *) 0 ;
37017 wxCommandEvent *arg2 = 0 ;
37018 PyObject * obj0 = 0 ;
37019 PyObject * obj1 = 0 ;
37020 char *kwnames[] = {
37021 (char *) "self",(char *) "event", NULL
37022 };
37023
37024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37026 if (SWIG_arg_fail(1)) SWIG_fail;
37027 {
37028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37029 if (SWIG_arg_fail(2)) SWIG_fail;
37030 if (arg2 == NULL) {
37031 SWIG_null_ref("wxCommandEvent");
37032 }
37033 if (SWIG_arg_fail(2)) SWIG_fail;
37034 }
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 (arg1)->Command(*arg2);
37038
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 Py_INCREF(Py_None); resultobj = Py_None;
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37050 PyObject *resultobj;
37051 wxControl *arg1 = (wxControl *) 0 ;
37052 wxString result;
37053 PyObject * obj0 = 0 ;
37054 char *kwnames[] = {
37055 (char *) "self", NULL
37056 };
37057
37058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37060 if (SWIG_arg_fail(1)) SWIG_fail;
37061 {
37062 PyThreadState* __tstate = wxPyBeginAllowThreads();
37063 result = (arg1)->GetLabel();
37064
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 {
37069 #if wxUSE_UNICODE
37070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37071 #else
37072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37073 #endif
37074 }
37075 return resultobj;
37076 fail:
37077 return NULL;
37078 }
37079
37080
37081 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37082 PyObject *resultobj;
37083 wxControl *arg1 = (wxControl *) 0 ;
37084 wxString *arg2 = 0 ;
37085 bool temp2 = false ;
37086 PyObject * obj0 = 0 ;
37087 PyObject * obj1 = 0 ;
37088 char *kwnames[] = {
37089 (char *) "self",(char *) "label", NULL
37090 };
37091
37092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37094 if (SWIG_arg_fail(1)) SWIG_fail;
37095 {
37096 arg2 = wxString_in_helper(obj1);
37097 if (arg2 == NULL) SWIG_fail;
37098 temp2 = true;
37099 }
37100 {
37101 PyThreadState* __tstate = wxPyBeginAllowThreads();
37102 (arg1)->SetLabel((wxString const &)*arg2);
37103
37104 wxPyEndAllowThreads(__tstate);
37105 if (PyErr_Occurred()) SWIG_fail;
37106 }
37107 Py_INCREF(Py_None); resultobj = Py_None;
37108 {
37109 if (temp2)
37110 delete arg2;
37111 }
37112 return resultobj;
37113 fail:
37114 {
37115 if (temp2)
37116 delete arg2;
37117 }
37118 return NULL;
37119 }
37120
37121
37122 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37123 PyObject *resultobj;
37124 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37125 wxVisualAttributes result;
37126 PyObject * obj0 = 0 ;
37127 char *kwnames[] = {
37128 (char *) "variant", NULL
37129 };
37130
37131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37132 if (obj0) {
37133 {
37134 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37135 if (SWIG_arg_fail(1)) SWIG_fail;
37136 }
37137 }
37138 {
37139 if (!wxPyCheckForApp()) SWIG_fail;
37140 PyThreadState* __tstate = wxPyBeginAllowThreads();
37141 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37142
37143 wxPyEndAllowThreads(__tstate);
37144 if (PyErr_Occurred()) SWIG_fail;
37145 }
37146 {
37147 wxVisualAttributes * resultptr;
37148 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37149 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37150 }
37151 return resultobj;
37152 fail:
37153 return NULL;
37154 }
37155
37156
37157 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37158 PyObject *obj;
37159 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37160 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37161 Py_INCREF(obj);
37162 return Py_BuildValue((char *)"");
37163 }
37164 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37165 PyObject *resultobj;
37166 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37167 wxString *arg2 = 0 ;
37168 PyObject *arg3 = (PyObject *) NULL ;
37169 int result;
37170 bool temp2 = false ;
37171 PyObject * obj0 = 0 ;
37172 PyObject * obj1 = 0 ;
37173 PyObject * obj2 = 0 ;
37174 char *kwnames[] = {
37175 (char *) "self",(char *) "item",(char *) "clientData", NULL
37176 };
37177
37178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37180 if (SWIG_arg_fail(1)) SWIG_fail;
37181 {
37182 arg2 = wxString_in_helper(obj1);
37183 if (arg2 == NULL) SWIG_fail;
37184 temp2 = true;
37185 }
37186 if (obj2) {
37187 arg3 = obj2;
37188 }
37189 {
37190 PyThreadState* __tstate = wxPyBeginAllowThreads();
37191 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37192
37193 wxPyEndAllowThreads(__tstate);
37194 if (PyErr_Occurred()) SWIG_fail;
37195 }
37196 {
37197 resultobj = SWIG_From_int((int)(result));
37198 }
37199 {
37200 if (temp2)
37201 delete arg2;
37202 }
37203 return resultobj;
37204 fail:
37205 {
37206 if (temp2)
37207 delete arg2;
37208 }
37209 return NULL;
37210 }
37211
37212
37213 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37214 PyObject *resultobj;
37215 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37216 wxArrayString *arg2 = 0 ;
37217 bool temp2 = false ;
37218 PyObject * obj0 = 0 ;
37219 PyObject * obj1 = 0 ;
37220 char *kwnames[] = {
37221 (char *) "self",(char *) "strings", NULL
37222 };
37223
37224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37226 if (SWIG_arg_fail(1)) SWIG_fail;
37227 {
37228 if (! PySequence_Check(obj1)) {
37229 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37230 SWIG_fail;
37231 }
37232 arg2 = new wxArrayString;
37233 temp2 = true;
37234 int i, len=PySequence_Length(obj1);
37235 for (i=0; i<len; i++) {
37236 PyObject* item = PySequence_GetItem(obj1, i);
37237 #if wxUSE_UNICODE
37238 PyObject* str = PyObject_Unicode(item);
37239 #else
37240 PyObject* str = PyObject_Str(item);
37241 #endif
37242 if (PyErr_Occurred()) SWIG_fail;
37243 arg2->Add(Py2wxString(str));
37244 Py_DECREF(item);
37245 Py_DECREF(str);
37246 }
37247 }
37248 {
37249 PyThreadState* __tstate = wxPyBeginAllowThreads();
37250 (arg1)->Append((wxArrayString const &)*arg2);
37251
37252 wxPyEndAllowThreads(__tstate);
37253 if (PyErr_Occurred()) SWIG_fail;
37254 }
37255 Py_INCREF(Py_None); resultobj = Py_None;
37256 {
37257 if (temp2) delete arg2;
37258 }
37259 return resultobj;
37260 fail:
37261 {
37262 if (temp2) delete arg2;
37263 }
37264 return NULL;
37265 }
37266
37267
37268 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37269 PyObject *resultobj;
37270 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37271 wxString *arg2 = 0 ;
37272 int arg3 ;
37273 PyObject *arg4 = (PyObject *) NULL ;
37274 int result;
37275 bool temp2 = false ;
37276 PyObject * obj0 = 0 ;
37277 PyObject * obj1 = 0 ;
37278 PyObject * obj2 = 0 ;
37279 PyObject * obj3 = 0 ;
37280 char *kwnames[] = {
37281 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37282 };
37283
37284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37286 if (SWIG_arg_fail(1)) SWIG_fail;
37287 {
37288 arg2 = wxString_in_helper(obj1);
37289 if (arg2 == NULL) SWIG_fail;
37290 temp2 = true;
37291 }
37292 {
37293 arg3 = (int)(SWIG_As_int(obj2));
37294 if (SWIG_arg_fail(3)) SWIG_fail;
37295 }
37296 if (obj3) {
37297 arg4 = obj3;
37298 }
37299 {
37300 PyThreadState* __tstate = wxPyBeginAllowThreads();
37301 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37302
37303 wxPyEndAllowThreads(__tstate);
37304 if (PyErr_Occurred()) SWIG_fail;
37305 }
37306 {
37307 resultobj = SWIG_From_int((int)(result));
37308 }
37309 {
37310 if (temp2)
37311 delete arg2;
37312 }
37313 return resultobj;
37314 fail:
37315 {
37316 if (temp2)
37317 delete arg2;
37318 }
37319 return NULL;
37320 }
37321
37322
37323 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37324 PyObject *resultobj;
37325 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37326 PyObject * obj0 = 0 ;
37327 char *kwnames[] = {
37328 (char *) "self", NULL
37329 };
37330
37331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37333 if (SWIG_arg_fail(1)) SWIG_fail;
37334 {
37335 PyThreadState* __tstate = wxPyBeginAllowThreads();
37336 (arg1)->Clear();
37337
37338 wxPyEndAllowThreads(__tstate);
37339 if (PyErr_Occurred()) SWIG_fail;
37340 }
37341 Py_INCREF(Py_None); resultobj = Py_None;
37342 return resultobj;
37343 fail:
37344 return NULL;
37345 }
37346
37347
37348 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37349 PyObject *resultobj;
37350 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37351 int arg2 ;
37352 PyObject * obj0 = 0 ;
37353 PyObject * obj1 = 0 ;
37354 char *kwnames[] = {
37355 (char *) "self",(char *) "n", NULL
37356 };
37357
37358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37360 if (SWIG_arg_fail(1)) SWIG_fail;
37361 {
37362 arg2 = (int)(SWIG_As_int(obj1));
37363 if (SWIG_arg_fail(2)) SWIG_fail;
37364 }
37365 {
37366 PyThreadState* __tstate = wxPyBeginAllowThreads();
37367 (arg1)->Delete(arg2);
37368
37369 wxPyEndAllowThreads(__tstate);
37370 if (PyErr_Occurred()) SWIG_fail;
37371 }
37372 Py_INCREF(Py_None); resultobj = Py_None;
37373 return resultobj;
37374 fail:
37375 return NULL;
37376 }
37377
37378
37379 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37380 PyObject *resultobj;
37381 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37382 int arg2 ;
37383 PyObject *result;
37384 PyObject * obj0 = 0 ;
37385 PyObject * obj1 = 0 ;
37386 char *kwnames[] = {
37387 (char *) "self",(char *) "n", NULL
37388 };
37389
37390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37392 if (SWIG_arg_fail(1)) SWIG_fail;
37393 {
37394 arg2 = (int)(SWIG_As_int(obj1));
37395 if (SWIG_arg_fail(2)) SWIG_fail;
37396 }
37397 {
37398 PyThreadState* __tstate = wxPyBeginAllowThreads();
37399 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37400
37401 wxPyEndAllowThreads(__tstate);
37402 if (PyErr_Occurred()) SWIG_fail;
37403 }
37404 resultobj = result;
37405 return resultobj;
37406 fail:
37407 return NULL;
37408 }
37409
37410
37411 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37412 PyObject *resultobj;
37413 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37414 int arg2 ;
37415 PyObject *arg3 = (PyObject *) 0 ;
37416 PyObject * obj0 = 0 ;
37417 PyObject * obj1 = 0 ;
37418 PyObject * obj2 = 0 ;
37419 char *kwnames[] = {
37420 (char *) "self",(char *) "n",(char *) "clientData", NULL
37421 };
37422
37423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37425 if (SWIG_arg_fail(1)) SWIG_fail;
37426 {
37427 arg2 = (int)(SWIG_As_int(obj1));
37428 if (SWIG_arg_fail(2)) SWIG_fail;
37429 }
37430 arg3 = obj2;
37431 {
37432 PyThreadState* __tstate = wxPyBeginAllowThreads();
37433 wxItemContainer_SetClientData(arg1,arg2,arg3);
37434
37435 wxPyEndAllowThreads(__tstate);
37436 if (PyErr_Occurred()) SWIG_fail;
37437 }
37438 Py_INCREF(Py_None); resultobj = Py_None;
37439 return resultobj;
37440 fail:
37441 return NULL;
37442 }
37443
37444
37445 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37446 PyObject *resultobj;
37447 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37448 int result;
37449 PyObject * obj0 = 0 ;
37450 char *kwnames[] = {
37451 (char *) "self", NULL
37452 };
37453
37454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37456 if (SWIG_arg_fail(1)) SWIG_fail;
37457 {
37458 PyThreadState* __tstate = wxPyBeginAllowThreads();
37459 result = (int)((wxItemContainer const *)arg1)->GetCount();
37460
37461 wxPyEndAllowThreads(__tstate);
37462 if (PyErr_Occurred()) SWIG_fail;
37463 }
37464 {
37465 resultobj = SWIG_From_int((int)(result));
37466 }
37467 return resultobj;
37468 fail:
37469 return NULL;
37470 }
37471
37472
37473 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37474 PyObject *resultobj;
37475 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37476 bool result;
37477 PyObject * obj0 = 0 ;
37478 char *kwnames[] = {
37479 (char *) "self", NULL
37480 };
37481
37482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37484 if (SWIG_arg_fail(1)) SWIG_fail;
37485 {
37486 PyThreadState* __tstate = wxPyBeginAllowThreads();
37487 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37488
37489 wxPyEndAllowThreads(__tstate);
37490 if (PyErr_Occurred()) SWIG_fail;
37491 }
37492 {
37493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37494 }
37495 return resultobj;
37496 fail:
37497 return NULL;
37498 }
37499
37500
37501 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37502 PyObject *resultobj;
37503 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37504 int arg2 ;
37505 wxString result;
37506 PyObject * obj0 = 0 ;
37507 PyObject * obj1 = 0 ;
37508 char *kwnames[] = {
37509 (char *) "self",(char *) "n", NULL
37510 };
37511
37512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37514 if (SWIG_arg_fail(1)) SWIG_fail;
37515 {
37516 arg2 = (int)(SWIG_As_int(obj1));
37517 if (SWIG_arg_fail(2)) SWIG_fail;
37518 }
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37522
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 {
37527 #if wxUSE_UNICODE
37528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37529 #else
37530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37531 #endif
37532 }
37533 return resultobj;
37534 fail:
37535 return NULL;
37536 }
37537
37538
37539 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37540 PyObject *resultobj;
37541 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37542 wxArrayString result;
37543 PyObject * obj0 = 0 ;
37544 char *kwnames[] = {
37545 (char *) "self", NULL
37546 };
37547
37548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37550 if (SWIG_arg_fail(1)) SWIG_fail;
37551 {
37552 PyThreadState* __tstate = wxPyBeginAllowThreads();
37553 result = ((wxItemContainer const *)arg1)->GetStrings();
37554
37555 wxPyEndAllowThreads(__tstate);
37556 if (PyErr_Occurred()) SWIG_fail;
37557 }
37558 {
37559 resultobj = wxArrayString2PyList_helper(result);
37560 }
37561 return resultobj;
37562 fail:
37563 return NULL;
37564 }
37565
37566
37567 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37568 PyObject *resultobj;
37569 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37570 int arg2 ;
37571 wxString *arg3 = 0 ;
37572 bool temp3 = false ;
37573 PyObject * obj0 = 0 ;
37574 PyObject * obj1 = 0 ;
37575 PyObject * obj2 = 0 ;
37576 char *kwnames[] = {
37577 (char *) "self",(char *) "n",(char *) "s", NULL
37578 };
37579
37580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37582 if (SWIG_arg_fail(1)) SWIG_fail;
37583 {
37584 arg2 = (int)(SWIG_As_int(obj1));
37585 if (SWIG_arg_fail(2)) SWIG_fail;
37586 }
37587 {
37588 arg3 = wxString_in_helper(obj2);
37589 if (arg3 == NULL) SWIG_fail;
37590 temp3 = true;
37591 }
37592 {
37593 PyThreadState* __tstate = wxPyBeginAllowThreads();
37594 (arg1)->SetString(arg2,(wxString const &)*arg3);
37595
37596 wxPyEndAllowThreads(__tstate);
37597 if (PyErr_Occurred()) SWIG_fail;
37598 }
37599 Py_INCREF(Py_None); resultobj = Py_None;
37600 {
37601 if (temp3)
37602 delete arg3;
37603 }
37604 return resultobj;
37605 fail:
37606 {
37607 if (temp3)
37608 delete arg3;
37609 }
37610 return NULL;
37611 }
37612
37613
37614 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37615 PyObject *resultobj;
37616 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37617 wxString *arg2 = 0 ;
37618 int result;
37619 bool temp2 = false ;
37620 PyObject * obj0 = 0 ;
37621 PyObject * obj1 = 0 ;
37622 char *kwnames[] = {
37623 (char *) "self",(char *) "s", NULL
37624 };
37625
37626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37628 if (SWIG_arg_fail(1)) SWIG_fail;
37629 {
37630 arg2 = wxString_in_helper(obj1);
37631 if (arg2 == NULL) SWIG_fail;
37632 temp2 = true;
37633 }
37634 {
37635 PyThreadState* __tstate = wxPyBeginAllowThreads();
37636 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37637
37638 wxPyEndAllowThreads(__tstate);
37639 if (PyErr_Occurred()) SWIG_fail;
37640 }
37641 {
37642 resultobj = SWIG_From_int((int)(result));
37643 }
37644 {
37645 if (temp2)
37646 delete arg2;
37647 }
37648 return resultobj;
37649 fail:
37650 {
37651 if (temp2)
37652 delete arg2;
37653 }
37654 return NULL;
37655 }
37656
37657
37658 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37659 PyObject *resultobj;
37660 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37661 int arg2 ;
37662 PyObject * obj0 = 0 ;
37663 PyObject * obj1 = 0 ;
37664 char *kwnames[] = {
37665 (char *) "self",(char *) "n", NULL
37666 };
37667
37668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37670 if (SWIG_arg_fail(1)) SWIG_fail;
37671 {
37672 arg2 = (int)(SWIG_As_int(obj1));
37673 if (SWIG_arg_fail(2)) SWIG_fail;
37674 }
37675 {
37676 PyThreadState* __tstate = wxPyBeginAllowThreads();
37677 (arg1)->SetSelection(arg2);
37678
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 Py_INCREF(Py_None); resultobj = Py_None;
37683 return resultobj;
37684 fail:
37685 return NULL;
37686 }
37687
37688
37689 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37690 PyObject *resultobj;
37691 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37692 int result;
37693 PyObject * obj0 = 0 ;
37694 char *kwnames[] = {
37695 (char *) "self", NULL
37696 };
37697
37698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37700 if (SWIG_arg_fail(1)) SWIG_fail;
37701 {
37702 PyThreadState* __tstate = wxPyBeginAllowThreads();
37703 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37704
37705 wxPyEndAllowThreads(__tstate);
37706 if (PyErr_Occurred()) SWIG_fail;
37707 }
37708 {
37709 resultobj = SWIG_From_int((int)(result));
37710 }
37711 return resultobj;
37712 fail:
37713 return NULL;
37714 }
37715
37716
37717 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37718 PyObject *resultobj;
37719 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37720 wxString *arg2 = 0 ;
37721 bool result;
37722 bool temp2 = false ;
37723 PyObject * obj0 = 0 ;
37724 PyObject * obj1 = 0 ;
37725 char *kwnames[] = {
37726 (char *) "self",(char *) "s", NULL
37727 };
37728
37729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37731 if (SWIG_arg_fail(1)) SWIG_fail;
37732 {
37733 arg2 = wxString_in_helper(obj1);
37734 if (arg2 == NULL) SWIG_fail;
37735 temp2 = true;
37736 }
37737 {
37738 PyThreadState* __tstate = wxPyBeginAllowThreads();
37739 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37740
37741 wxPyEndAllowThreads(__tstate);
37742 if (PyErr_Occurred()) SWIG_fail;
37743 }
37744 {
37745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37746 }
37747 {
37748 if (temp2)
37749 delete arg2;
37750 }
37751 return resultobj;
37752 fail:
37753 {
37754 if (temp2)
37755 delete arg2;
37756 }
37757 return NULL;
37758 }
37759
37760
37761 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37762 PyObject *resultobj;
37763 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37764 wxString result;
37765 PyObject * obj0 = 0 ;
37766 char *kwnames[] = {
37767 (char *) "self", NULL
37768 };
37769
37770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37772 if (SWIG_arg_fail(1)) SWIG_fail;
37773 {
37774 PyThreadState* __tstate = wxPyBeginAllowThreads();
37775 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37776
37777 wxPyEndAllowThreads(__tstate);
37778 if (PyErr_Occurred()) SWIG_fail;
37779 }
37780 {
37781 #if wxUSE_UNICODE
37782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37783 #else
37784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37785 #endif
37786 }
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37794 PyObject *resultobj;
37795 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37796 int arg2 ;
37797 PyObject * obj0 = 0 ;
37798 PyObject * obj1 = 0 ;
37799 char *kwnames[] = {
37800 (char *) "self",(char *) "n", NULL
37801 };
37802
37803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37805 if (SWIG_arg_fail(1)) SWIG_fail;
37806 {
37807 arg2 = (int)(SWIG_As_int(obj1));
37808 if (SWIG_arg_fail(2)) SWIG_fail;
37809 }
37810 {
37811 PyThreadState* __tstate = wxPyBeginAllowThreads();
37812 (arg1)->Select(arg2);
37813
37814 wxPyEndAllowThreads(__tstate);
37815 if (PyErr_Occurred()) SWIG_fail;
37816 }
37817 Py_INCREF(Py_None); resultobj = Py_None;
37818 return resultobj;
37819 fail:
37820 return NULL;
37821 }
37822
37823
37824 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37825 PyObject *obj;
37826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37827 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37828 Py_INCREF(obj);
37829 return Py_BuildValue((char *)"");
37830 }
37831 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37832 PyObject *obj;
37833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37834 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37835 Py_INCREF(obj);
37836 return Py_BuildValue((char *)"");
37837 }
37838 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37839 PyObject *resultobj;
37840 wxSizerItem *result;
37841 char *kwnames[] = {
37842 NULL
37843 };
37844
37845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37846 {
37847 PyThreadState* __tstate = wxPyBeginAllowThreads();
37848 result = (wxSizerItem *)new wxSizerItem();
37849
37850 wxPyEndAllowThreads(__tstate);
37851 if (PyErr_Occurred()) SWIG_fail;
37852 }
37853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37861 PyObject *resultobj;
37862 wxWindow *arg1 = (wxWindow *) 0 ;
37863 int arg2 ;
37864 int arg3 ;
37865 int arg4 ;
37866 PyObject *arg5 = (PyObject *) NULL ;
37867 wxSizerItem *result;
37868 PyObject * obj0 = 0 ;
37869 PyObject * obj1 = 0 ;
37870 PyObject * obj2 = 0 ;
37871 PyObject * obj3 = 0 ;
37872 PyObject * obj4 = 0 ;
37873 char *kwnames[] = {
37874 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37875 };
37876
37877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37879 if (SWIG_arg_fail(1)) SWIG_fail;
37880 {
37881 arg2 = (int)(SWIG_As_int(obj1));
37882 if (SWIG_arg_fail(2)) SWIG_fail;
37883 }
37884 {
37885 arg3 = (int)(SWIG_As_int(obj2));
37886 if (SWIG_arg_fail(3)) SWIG_fail;
37887 }
37888 {
37889 arg4 = (int)(SWIG_As_int(obj3));
37890 if (SWIG_arg_fail(4)) SWIG_fail;
37891 }
37892 if (obj4) {
37893 arg5 = obj4;
37894 }
37895 {
37896 PyThreadState* __tstate = wxPyBeginAllowThreads();
37897 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37898
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37910 PyObject *resultobj;
37911 int arg1 ;
37912 int arg2 ;
37913 int arg3 ;
37914 int arg4 ;
37915 int arg5 ;
37916 PyObject *arg6 = (PyObject *) NULL ;
37917 wxSizerItem *result;
37918 PyObject * obj0 = 0 ;
37919 PyObject * obj1 = 0 ;
37920 PyObject * obj2 = 0 ;
37921 PyObject * obj3 = 0 ;
37922 PyObject * obj4 = 0 ;
37923 PyObject * obj5 = 0 ;
37924 char *kwnames[] = {
37925 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37926 };
37927
37928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37929 {
37930 arg1 = (int)(SWIG_As_int(obj0));
37931 if (SWIG_arg_fail(1)) SWIG_fail;
37932 }
37933 {
37934 arg2 = (int)(SWIG_As_int(obj1));
37935 if (SWIG_arg_fail(2)) SWIG_fail;
37936 }
37937 {
37938 arg3 = (int)(SWIG_As_int(obj2));
37939 if (SWIG_arg_fail(3)) SWIG_fail;
37940 }
37941 {
37942 arg4 = (int)(SWIG_As_int(obj3));
37943 if (SWIG_arg_fail(4)) SWIG_fail;
37944 }
37945 {
37946 arg5 = (int)(SWIG_As_int(obj4));
37947 if (SWIG_arg_fail(5)) SWIG_fail;
37948 }
37949 if (obj5) {
37950 arg6 = obj5;
37951 }
37952 {
37953 PyThreadState* __tstate = wxPyBeginAllowThreads();
37954 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37955
37956 wxPyEndAllowThreads(__tstate);
37957 if (PyErr_Occurred()) SWIG_fail;
37958 }
37959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37960 return resultobj;
37961 fail:
37962 return NULL;
37963 }
37964
37965
37966 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37967 PyObject *resultobj;
37968 wxSizer *arg1 = (wxSizer *) 0 ;
37969 int arg2 ;
37970 int arg3 ;
37971 int arg4 ;
37972 PyObject *arg5 = (PyObject *) NULL ;
37973 wxSizerItem *result;
37974 PyObject * obj0 = 0 ;
37975 PyObject * obj1 = 0 ;
37976 PyObject * obj2 = 0 ;
37977 PyObject * obj3 = 0 ;
37978 PyObject * obj4 = 0 ;
37979 char *kwnames[] = {
37980 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37981 };
37982
37983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37985 if (SWIG_arg_fail(1)) SWIG_fail;
37986 {
37987 arg2 = (int)(SWIG_As_int(obj1));
37988 if (SWIG_arg_fail(2)) SWIG_fail;
37989 }
37990 {
37991 arg3 = (int)(SWIG_As_int(obj2));
37992 if (SWIG_arg_fail(3)) SWIG_fail;
37993 }
37994 {
37995 arg4 = (int)(SWIG_As_int(obj3));
37996 if (SWIG_arg_fail(4)) SWIG_fail;
37997 }
37998 if (obj4) {
37999 arg5 = obj4;
38000 }
38001 {
38002 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38004
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38009 return resultobj;
38010 fail:
38011 return NULL;
38012 }
38013
38014
38015 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38016 PyObject *resultobj;
38017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38018 PyObject * obj0 = 0 ;
38019 char *kwnames[] = {
38020 (char *) "self", NULL
38021 };
38022
38023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38025 if (SWIG_arg_fail(1)) SWIG_fail;
38026 {
38027 PyThreadState* __tstate = wxPyBeginAllowThreads();
38028 (arg1)->DeleteWindows();
38029
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 Py_INCREF(Py_None); resultobj = Py_None;
38034 return resultobj;
38035 fail:
38036 return NULL;
38037 }
38038
38039
38040 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38041 PyObject *resultobj;
38042 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38043 PyObject * obj0 = 0 ;
38044 char *kwnames[] = {
38045 (char *) "self", NULL
38046 };
38047
38048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38050 if (SWIG_arg_fail(1)) SWIG_fail;
38051 {
38052 PyThreadState* __tstate = wxPyBeginAllowThreads();
38053 (arg1)->DetachSizer();
38054
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 Py_INCREF(Py_None); resultobj = Py_None;
38059 return resultobj;
38060 fail:
38061 return NULL;
38062 }
38063
38064
38065 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38066 PyObject *resultobj;
38067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38068 wxSize result;
38069 PyObject * obj0 = 0 ;
38070 char *kwnames[] = {
38071 (char *) "self", NULL
38072 };
38073
38074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38076 if (SWIG_arg_fail(1)) SWIG_fail;
38077 {
38078 PyThreadState* __tstate = wxPyBeginAllowThreads();
38079 result = (arg1)->GetSize();
38080
38081 wxPyEndAllowThreads(__tstate);
38082 if (PyErr_Occurred()) SWIG_fail;
38083 }
38084 {
38085 wxSize * resultptr;
38086 resultptr = new wxSize((wxSize &)(result));
38087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38088 }
38089 return resultobj;
38090 fail:
38091 return NULL;
38092 }
38093
38094
38095 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38096 PyObject *resultobj;
38097 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38098 wxSize result;
38099 PyObject * obj0 = 0 ;
38100 char *kwnames[] = {
38101 (char *) "self", NULL
38102 };
38103
38104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38106 if (SWIG_arg_fail(1)) SWIG_fail;
38107 {
38108 PyThreadState* __tstate = wxPyBeginAllowThreads();
38109 result = (arg1)->CalcMin();
38110
38111 wxPyEndAllowThreads(__tstate);
38112 if (PyErr_Occurred()) SWIG_fail;
38113 }
38114 {
38115 wxSize * resultptr;
38116 resultptr = new wxSize((wxSize &)(result));
38117 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38118 }
38119 return resultobj;
38120 fail:
38121 return NULL;
38122 }
38123
38124
38125 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38126 PyObject *resultobj;
38127 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38128 wxPoint arg2 ;
38129 wxSize arg3 ;
38130 PyObject * obj0 = 0 ;
38131 PyObject * obj1 = 0 ;
38132 PyObject * obj2 = 0 ;
38133 char *kwnames[] = {
38134 (char *) "self",(char *) "pos",(char *) "size", NULL
38135 };
38136
38137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38139 if (SWIG_arg_fail(1)) SWIG_fail;
38140 {
38141 wxPoint * argp;
38142 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38143 if (SWIG_arg_fail(2)) SWIG_fail;
38144 if (argp == NULL) {
38145 SWIG_null_ref("wxPoint");
38146 }
38147 if (SWIG_arg_fail(2)) SWIG_fail;
38148 arg2 = *argp;
38149 }
38150 {
38151 wxSize * argp;
38152 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38153 if (SWIG_arg_fail(3)) SWIG_fail;
38154 if (argp == NULL) {
38155 SWIG_null_ref("wxSize");
38156 }
38157 if (SWIG_arg_fail(3)) SWIG_fail;
38158 arg3 = *argp;
38159 }
38160 {
38161 PyThreadState* __tstate = wxPyBeginAllowThreads();
38162 (arg1)->SetDimension(arg2,arg3);
38163
38164 wxPyEndAllowThreads(__tstate);
38165 if (PyErr_Occurred()) SWIG_fail;
38166 }
38167 Py_INCREF(Py_None); resultobj = Py_None;
38168 return resultobj;
38169 fail:
38170 return NULL;
38171 }
38172
38173
38174 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38175 PyObject *resultobj;
38176 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38177 wxSize result;
38178 PyObject * obj0 = 0 ;
38179 char *kwnames[] = {
38180 (char *) "self", NULL
38181 };
38182
38183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38185 if (SWIG_arg_fail(1)) SWIG_fail;
38186 {
38187 PyThreadState* __tstate = wxPyBeginAllowThreads();
38188 result = (arg1)->GetMinSize();
38189
38190 wxPyEndAllowThreads(__tstate);
38191 if (PyErr_Occurred()) SWIG_fail;
38192 }
38193 {
38194 wxSize * resultptr;
38195 resultptr = new wxSize((wxSize &)(result));
38196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38197 }
38198 return resultobj;
38199 fail:
38200 return NULL;
38201 }
38202
38203
38204 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38205 PyObject *resultobj;
38206 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38207 wxSize result;
38208 PyObject * obj0 = 0 ;
38209 char *kwnames[] = {
38210 (char *) "self", NULL
38211 };
38212
38213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38215 if (SWIG_arg_fail(1)) SWIG_fail;
38216 {
38217 PyThreadState* __tstate = wxPyBeginAllowThreads();
38218 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38219
38220 wxPyEndAllowThreads(__tstate);
38221 if (PyErr_Occurred()) SWIG_fail;
38222 }
38223 {
38224 wxSize * resultptr;
38225 resultptr = new wxSize((wxSize &)(result));
38226 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38227 }
38228 return resultobj;
38229 fail:
38230 return NULL;
38231 }
38232
38233
38234 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38235 PyObject *resultobj;
38236 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38237 int arg2 ;
38238 int arg3 ;
38239 PyObject * obj0 = 0 ;
38240 PyObject * obj1 = 0 ;
38241 PyObject * obj2 = 0 ;
38242 char *kwnames[] = {
38243 (char *) "self",(char *) "x",(char *) "y", NULL
38244 };
38245
38246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38248 if (SWIG_arg_fail(1)) SWIG_fail;
38249 {
38250 arg2 = (int)(SWIG_As_int(obj1));
38251 if (SWIG_arg_fail(2)) SWIG_fail;
38252 }
38253 {
38254 arg3 = (int)(SWIG_As_int(obj2));
38255 if (SWIG_arg_fail(3)) SWIG_fail;
38256 }
38257 {
38258 PyThreadState* __tstate = wxPyBeginAllowThreads();
38259 (arg1)->SetInitSize(arg2,arg3);
38260
38261 wxPyEndAllowThreads(__tstate);
38262 if (PyErr_Occurred()) SWIG_fail;
38263 }
38264 Py_INCREF(Py_None); resultobj = Py_None;
38265 return resultobj;
38266 fail:
38267 return NULL;
38268 }
38269
38270
38271 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38272 PyObject *resultobj;
38273 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38274 int arg2 ;
38275 int arg3 ;
38276 PyObject * obj0 = 0 ;
38277 PyObject * obj1 = 0 ;
38278 PyObject * obj2 = 0 ;
38279 char *kwnames[] = {
38280 (char *) "self",(char *) "width",(char *) "height", NULL
38281 };
38282
38283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38285 if (SWIG_arg_fail(1)) SWIG_fail;
38286 {
38287 arg2 = (int)(SWIG_As_int(obj1));
38288 if (SWIG_arg_fail(2)) SWIG_fail;
38289 }
38290 {
38291 arg3 = (int)(SWIG_As_int(obj2));
38292 if (SWIG_arg_fail(3)) SWIG_fail;
38293 }
38294 {
38295 PyThreadState* __tstate = wxPyBeginAllowThreads();
38296 (arg1)->SetRatio(arg2,arg3);
38297
38298 wxPyEndAllowThreads(__tstate);
38299 if (PyErr_Occurred()) SWIG_fail;
38300 }
38301 Py_INCREF(Py_None); resultobj = Py_None;
38302 return resultobj;
38303 fail:
38304 return NULL;
38305 }
38306
38307
38308 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38309 PyObject *resultobj;
38310 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38311 wxSize arg2 ;
38312 PyObject * obj0 = 0 ;
38313 PyObject * obj1 = 0 ;
38314 char *kwnames[] = {
38315 (char *) "self",(char *) "size", NULL
38316 };
38317
38318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38320 if (SWIG_arg_fail(1)) SWIG_fail;
38321 {
38322 wxSize * argp;
38323 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38324 if (SWIG_arg_fail(2)) SWIG_fail;
38325 if (argp == NULL) {
38326 SWIG_null_ref("wxSize");
38327 }
38328 if (SWIG_arg_fail(2)) SWIG_fail;
38329 arg2 = *argp;
38330 }
38331 {
38332 PyThreadState* __tstate = wxPyBeginAllowThreads();
38333 (arg1)->SetRatio(arg2);
38334
38335 wxPyEndAllowThreads(__tstate);
38336 if (PyErr_Occurred()) SWIG_fail;
38337 }
38338 Py_INCREF(Py_None); resultobj = Py_None;
38339 return resultobj;
38340 fail:
38341 return NULL;
38342 }
38343
38344
38345 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38346 PyObject *resultobj;
38347 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38348 float arg2 ;
38349 PyObject * obj0 = 0 ;
38350 PyObject * obj1 = 0 ;
38351 char *kwnames[] = {
38352 (char *) "self",(char *) "ratio", NULL
38353 };
38354
38355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38357 if (SWIG_arg_fail(1)) SWIG_fail;
38358 {
38359 arg2 = (float)(SWIG_As_float(obj1));
38360 if (SWIG_arg_fail(2)) SWIG_fail;
38361 }
38362 {
38363 PyThreadState* __tstate = wxPyBeginAllowThreads();
38364 (arg1)->SetRatio(arg2);
38365
38366 wxPyEndAllowThreads(__tstate);
38367 if (PyErr_Occurred()) SWIG_fail;
38368 }
38369 Py_INCREF(Py_None); resultobj = Py_None;
38370 return resultobj;
38371 fail:
38372 return NULL;
38373 }
38374
38375
38376 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38377 PyObject *resultobj;
38378 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38379 float result;
38380 PyObject * obj0 = 0 ;
38381 char *kwnames[] = {
38382 (char *) "self", NULL
38383 };
38384
38385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38387 if (SWIG_arg_fail(1)) SWIG_fail;
38388 {
38389 PyThreadState* __tstate = wxPyBeginAllowThreads();
38390 result = (float)(arg1)->GetRatio();
38391
38392 wxPyEndAllowThreads(__tstate);
38393 if (PyErr_Occurred()) SWIG_fail;
38394 }
38395 {
38396 resultobj = SWIG_From_float((float)(result));
38397 }
38398 return resultobj;
38399 fail:
38400 return NULL;
38401 }
38402
38403
38404 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38405 PyObject *resultobj;
38406 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38407 wxRect result;
38408 PyObject * obj0 = 0 ;
38409 char *kwnames[] = {
38410 (char *) "self", NULL
38411 };
38412
38413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38415 if (SWIG_arg_fail(1)) SWIG_fail;
38416 {
38417 PyThreadState* __tstate = wxPyBeginAllowThreads();
38418 result = (arg1)->GetRect();
38419
38420 wxPyEndAllowThreads(__tstate);
38421 if (PyErr_Occurred()) SWIG_fail;
38422 }
38423 {
38424 wxRect * resultptr;
38425 resultptr = new wxRect((wxRect &)(result));
38426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38427 }
38428 return resultobj;
38429 fail:
38430 return NULL;
38431 }
38432
38433
38434 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38435 PyObject *resultobj;
38436 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38437 bool result;
38438 PyObject * obj0 = 0 ;
38439 char *kwnames[] = {
38440 (char *) "self", NULL
38441 };
38442
38443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38445 if (SWIG_arg_fail(1)) SWIG_fail;
38446 {
38447 PyThreadState* __tstate = wxPyBeginAllowThreads();
38448 result = (bool)(arg1)->IsWindow();
38449
38450 wxPyEndAllowThreads(__tstate);
38451 if (PyErr_Occurred()) SWIG_fail;
38452 }
38453 {
38454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38455 }
38456 return resultobj;
38457 fail:
38458 return NULL;
38459 }
38460
38461
38462 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38463 PyObject *resultobj;
38464 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38465 bool result;
38466 PyObject * obj0 = 0 ;
38467 char *kwnames[] = {
38468 (char *) "self", NULL
38469 };
38470
38471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38473 if (SWIG_arg_fail(1)) SWIG_fail;
38474 {
38475 PyThreadState* __tstate = wxPyBeginAllowThreads();
38476 result = (bool)(arg1)->IsSizer();
38477
38478 wxPyEndAllowThreads(__tstate);
38479 if (PyErr_Occurred()) SWIG_fail;
38480 }
38481 {
38482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38483 }
38484 return resultobj;
38485 fail:
38486 return NULL;
38487 }
38488
38489
38490 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38491 PyObject *resultobj;
38492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38493 bool result;
38494 PyObject * obj0 = 0 ;
38495 char *kwnames[] = {
38496 (char *) "self", NULL
38497 };
38498
38499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38501 if (SWIG_arg_fail(1)) SWIG_fail;
38502 {
38503 PyThreadState* __tstate = wxPyBeginAllowThreads();
38504 result = (bool)(arg1)->IsSpacer();
38505
38506 wxPyEndAllowThreads(__tstate);
38507 if (PyErr_Occurred()) SWIG_fail;
38508 }
38509 {
38510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38511 }
38512 return resultobj;
38513 fail:
38514 return NULL;
38515 }
38516
38517
38518 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38519 PyObject *resultobj;
38520 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38521 int arg2 ;
38522 PyObject * obj0 = 0 ;
38523 PyObject * obj1 = 0 ;
38524 char *kwnames[] = {
38525 (char *) "self",(char *) "proportion", NULL
38526 };
38527
38528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38530 if (SWIG_arg_fail(1)) SWIG_fail;
38531 {
38532 arg2 = (int)(SWIG_As_int(obj1));
38533 if (SWIG_arg_fail(2)) SWIG_fail;
38534 }
38535 {
38536 PyThreadState* __tstate = wxPyBeginAllowThreads();
38537 (arg1)->SetProportion(arg2);
38538
38539 wxPyEndAllowThreads(__tstate);
38540 if (PyErr_Occurred()) SWIG_fail;
38541 }
38542 Py_INCREF(Py_None); resultobj = Py_None;
38543 return resultobj;
38544 fail:
38545 return NULL;
38546 }
38547
38548
38549 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38550 PyObject *resultobj;
38551 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38552 int result;
38553 PyObject * obj0 = 0 ;
38554 char *kwnames[] = {
38555 (char *) "self", NULL
38556 };
38557
38558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38560 if (SWIG_arg_fail(1)) SWIG_fail;
38561 {
38562 PyThreadState* __tstate = wxPyBeginAllowThreads();
38563 result = (int)(arg1)->GetProportion();
38564
38565 wxPyEndAllowThreads(__tstate);
38566 if (PyErr_Occurred()) SWIG_fail;
38567 }
38568 {
38569 resultobj = SWIG_From_int((int)(result));
38570 }
38571 return resultobj;
38572 fail:
38573 return NULL;
38574 }
38575
38576
38577 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38578 PyObject *resultobj;
38579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38580 int arg2 ;
38581 PyObject * obj0 = 0 ;
38582 PyObject * obj1 = 0 ;
38583 char *kwnames[] = {
38584 (char *) "self",(char *) "flag", NULL
38585 };
38586
38587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38589 if (SWIG_arg_fail(1)) SWIG_fail;
38590 {
38591 arg2 = (int)(SWIG_As_int(obj1));
38592 if (SWIG_arg_fail(2)) SWIG_fail;
38593 }
38594 {
38595 PyThreadState* __tstate = wxPyBeginAllowThreads();
38596 (arg1)->SetFlag(arg2);
38597
38598 wxPyEndAllowThreads(__tstate);
38599 if (PyErr_Occurred()) SWIG_fail;
38600 }
38601 Py_INCREF(Py_None); resultobj = Py_None;
38602 return resultobj;
38603 fail:
38604 return NULL;
38605 }
38606
38607
38608 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38609 PyObject *resultobj;
38610 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38611 int result;
38612 PyObject * obj0 = 0 ;
38613 char *kwnames[] = {
38614 (char *) "self", NULL
38615 };
38616
38617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38619 if (SWIG_arg_fail(1)) SWIG_fail;
38620 {
38621 PyThreadState* __tstate = wxPyBeginAllowThreads();
38622 result = (int)(arg1)->GetFlag();
38623
38624 wxPyEndAllowThreads(__tstate);
38625 if (PyErr_Occurred()) SWIG_fail;
38626 }
38627 {
38628 resultobj = SWIG_From_int((int)(result));
38629 }
38630 return resultobj;
38631 fail:
38632 return NULL;
38633 }
38634
38635
38636 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38637 PyObject *resultobj;
38638 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38639 int arg2 ;
38640 PyObject * obj0 = 0 ;
38641 PyObject * obj1 = 0 ;
38642 char *kwnames[] = {
38643 (char *) "self",(char *) "border", NULL
38644 };
38645
38646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38648 if (SWIG_arg_fail(1)) SWIG_fail;
38649 {
38650 arg2 = (int)(SWIG_As_int(obj1));
38651 if (SWIG_arg_fail(2)) SWIG_fail;
38652 }
38653 {
38654 PyThreadState* __tstate = wxPyBeginAllowThreads();
38655 (arg1)->SetBorder(arg2);
38656
38657 wxPyEndAllowThreads(__tstate);
38658 if (PyErr_Occurred()) SWIG_fail;
38659 }
38660 Py_INCREF(Py_None); resultobj = Py_None;
38661 return resultobj;
38662 fail:
38663 return NULL;
38664 }
38665
38666
38667 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38668 PyObject *resultobj;
38669 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38670 int result;
38671 PyObject * obj0 = 0 ;
38672 char *kwnames[] = {
38673 (char *) "self", NULL
38674 };
38675
38676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38678 if (SWIG_arg_fail(1)) SWIG_fail;
38679 {
38680 PyThreadState* __tstate = wxPyBeginAllowThreads();
38681 result = (int)(arg1)->GetBorder();
38682
38683 wxPyEndAllowThreads(__tstate);
38684 if (PyErr_Occurred()) SWIG_fail;
38685 }
38686 {
38687 resultobj = SWIG_From_int((int)(result));
38688 }
38689 return resultobj;
38690 fail:
38691 return NULL;
38692 }
38693
38694
38695 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38696 PyObject *resultobj;
38697 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38698 wxWindow *result;
38699 PyObject * obj0 = 0 ;
38700 char *kwnames[] = {
38701 (char *) "self", NULL
38702 };
38703
38704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38706 if (SWIG_arg_fail(1)) SWIG_fail;
38707 {
38708 PyThreadState* __tstate = wxPyBeginAllowThreads();
38709 result = (wxWindow *)(arg1)->GetWindow();
38710
38711 wxPyEndAllowThreads(__tstate);
38712 if (PyErr_Occurred()) SWIG_fail;
38713 }
38714 {
38715 resultobj = wxPyMake_wxObject(result, 0);
38716 }
38717 return resultobj;
38718 fail:
38719 return NULL;
38720 }
38721
38722
38723 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38724 PyObject *resultobj;
38725 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38726 wxWindow *arg2 = (wxWindow *) 0 ;
38727 PyObject * obj0 = 0 ;
38728 PyObject * obj1 = 0 ;
38729 char *kwnames[] = {
38730 (char *) "self",(char *) "window", NULL
38731 };
38732
38733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38735 if (SWIG_arg_fail(1)) SWIG_fail;
38736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38737 if (SWIG_arg_fail(2)) SWIG_fail;
38738 {
38739 PyThreadState* __tstate = wxPyBeginAllowThreads();
38740 (arg1)->SetWindow(arg2);
38741
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 Py_INCREF(Py_None); resultobj = Py_None;
38746 return resultobj;
38747 fail:
38748 return NULL;
38749 }
38750
38751
38752 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38753 PyObject *resultobj;
38754 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38755 wxSizer *result;
38756 PyObject * obj0 = 0 ;
38757 char *kwnames[] = {
38758 (char *) "self", NULL
38759 };
38760
38761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38763 if (SWIG_arg_fail(1)) SWIG_fail;
38764 {
38765 PyThreadState* __tstate = wxPyBeginAllowThreads();
38766 result = (wxSizer *)(arg1)->GetSizer();
38767
38768 wxPyEndAllowThreads(__tstate);
38769 if (PyErr_Occurred()) SWIG_fail;
38770 }
38771 {
38772 resultobj = wxPyMake_wxSizer(result, 0);
38773 }
38774 return resultobj;
38775 fail:
38776 return NULL;
38777 }
38778
38779
38780 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38781 PyObject *resultobj;
38782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38783 wxSizer *arg2 = (wxSizer *) 0 ;
38784 PyObject * obj0 = 0 ;
38785 PyObject * obj1 = 0 ;
38786 char *kwnames[] = {
38787 (char *) "self",(char *) "sizer", NULL
38788 };
38789
38790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38792 if (SWIG_arg_fail(1)) SWIG_fail;
38793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38794 if (SWIG_arg_fail(2)) SWIG_fail;
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 (arg1)->SetSizer(arg2);
38798
38799 wxPyEndAllowThreads(__tstate);
38800 if (PyErr_Occurred()) SWIG_fail;
38801 }
38802 Py_INCREF(Py_None); resultobj = Py_None;
38803 return resultobj;
38804 fail:
38805 return NULL;
38806 }
38807
38808
38809 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38810 PyObject *resultobj;
38811 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38812 wxSize *result;
38813 PyObject * obj0 = 0 ;
38814 char *kwnames[] = {
38815 (char *) "self", NULL
38816 };
38817
38818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38820 if (SWIG_arg_fail(1)) SWIG_fail;
38821 {
38822 PyThreadState* __tstate = wxPyBeginAllowThreads();
38823 {
38824 wxSize const &_result_ref = (arg1)->GetSpacer();
38825 result = (wxSize *) &_result_ref;
38826 }
38827
38828 wxPyEndAllowThreads(__tstate);
38829 if (PyErr_Occurred()) SWIG_fail;
38830 }
38831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38832 return resultobj;
38833 fail:
38834 return NULL;
38835 }
38836
38837
38838 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38839 PyObject *resultobj;
38840 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38841 wxSize *arg2 = 0 ;
38842 wxSize temp2 ;
38843 PyObject * obj0 = 0 ;
38844 PyObject * obj1 = 0 ;
38845 char *kwnames[] = {
38846 (char *) "self",(char *) "size", NULL
38847 };
38848
38849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38851 if (SWIG_arg_fail(1)) SWIG_fail;
38852 {
38853 arg2 = &temp2;
38854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38855 }
38856 {
38857 PyThreadState* __tstate = wxPyBeginAllowThreads();
38858 (arg1)->SetSpacer((wxSize const &)*arg2);
38859
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 Py_INCREF(Py_None); resultobj = Py_None;
38864 return resultobj;
38865 fail:
38866 return NULL;
38867 }
38868
38869
38870 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38871 PyObject *resultobj;
38872 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38873 bool arg2 ;
38874 PyObject * obj0 = 0 ;
38875 PyObject * obj1 = 0 ;
38876 char *kwnames[] = {
38877 (char *) "self",(char *) "show", NULL
38878 };
38879
38880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38882 if (SWIG_arg_fail(1)) SWIG_fail;
38883 {
38884 arg2 = (bool)(SWIG_As_bool(obj1));
38885 if (SWIG_arg_fail(2)) SWIG_fail;
38886 }
38887 {
38888 PyThreadState* __tstate = wxPyBeginAllowThreads();
38889 (arg1)->Show(arg2);
38890
38891 wxPyEndAllowThreads(__tstate);
38892 if (PyErr_Occurred()) SWIG_fail;
38893 }
38894 Py_INCREF(Py_None); resultobj = Py_None;
38895 return resultobj;
38896 fail:
38897 return NULL;
38898 }
38899
38900
38901 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38902 PyObject *resultobj;
38903 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38904 bool result;
38905 PyObject * obj0 = 0 ;
38906 char *kwnames[] = {
38907 (char *) "self", NULL
38908 };
38909
38910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38912 if (SWIG_arg_fail(1)) SWIG_fail;
38913 {
38914 PyThreadState* __tstate = wxPyBeginAllowThreads();
38915 result = (bool)(arg1)->IsShown();
38916
38917 wxPyEndAllowThreads(__tstate);
38918 if (PyErr_Occurred()) SWIG_fail;
38919 }
38920 {
38921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38922 }
38923 return resultobj;
38924 fail:
38925 return NULL;
38926 }
38927
38928
38929 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38930 PyObject *resultobj;
38931 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38932 wxPoint result;
38933 PyObject * obj0 = 0 ;
38934 char *kwnames[] = {
38935 (char *) "self", NULL
38936 };
38937
38938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38940 if (SWIG_arg_fail(1)) SWIG_fail;
38941 {
38942 PyThreadState* __tstate = wxPyBeginAllowThreads();
38943 result = (arg1)->GetPosition();
38944
38945 wxPyEndAllowThreads(__tstate);
38946 if (PyErr_Occurred()) SWIG_fail;
38947 }
38948 {
38949 wxPoint * resultptr;
38950 resultptr = new wxPoint((wxPoint &)(result));
38951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38952 }
38953 return resultobj;
38954 fail:
38955 return NULL;
38956 }
38957
38958
38959 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38960 PyObject *resultobj;
38961 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38962 PyObject *result;
38963 PyObject * obj0 = 0 ;
38964 char *kwnames[] = {
38965 (char *) "self", NULL
38966 };
38967
38968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38970 if (SWIG_arg_fail(1)) SWIG_fail;
38971 {
38972 PyThreadState* __tstate = wxPyBeginAllowThreads();
38973 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38974
38975 wxPyEndAllowThreads(__tstate);
38976 if (PyErr_Occurred()) SWIG_fail;
38977 }
38978 resultobj = result;
38979 return resultobj;
38980 fail:
38981 return NULL;
38982 }
38983
38984
38985 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38986 PyObject *obj;
38987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38988 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38989 Py_INCREF(obj);
38990 return Py_BuildValue((char *)"");
38991 }
38992 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj;
38994 wxSizer *arg1 = (wxSizer *) 0 ;
38995 PyObject *arg2 = (PyObject *) 0 ;
38996 PyObject * obj0 = 0 ;
38997 PyObject * obj1 = 0 ;
38998 char *kwnames[] = {
38999 (char *) "self",(char *) "_self", NULL
39000 };
39001
39002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39004 if (SWIG_arg_fail(1)) SWIG_fail;
39005 arg2 = obj1;
39006 {
39007 PyThreadState* __tstate = wxPyBeginAllowThreads();
39008 wxSizer__setOORInfo(arg1,arg2);
39009
39010 wxPyEndAllowThreads(__tstate);
39011 if (PyErr_Occurred()) SWIG_fail;
39012 }
39013 Py_INCREF(Py_None); resultobj = Py_None;
39014 return resultobj;
39015 fail:
39016 return NULL;
39017 }
39018
39019
39020 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39021 PyObject *resultobj;
39022 wxSizer *arg1 = (wxSizer *) 0 ;
39023 PyObject *arg2 = (PyObject *) 0 ;
39024 int arg3 = (int) 0 ;
39025 int arg4 = (int) 0 ;
39026 int arg5 = (int) 0 ;
39027 PyObject *arg6 = (PyObject *) NULL ;
39028 wxSizerItem *result;
39029 PyObject * obj0 = 0 ;
39030 PyObject * obj1 = 0 ;
39031 PyObject * obj2 = 0 ;
39032 PyObject * obj3 = 0 ;
39033 PyObject * obj4 = 0 ;
39034 PyObject * obj5 = 0 ;
39035 char *kwnames[] = {
39036 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39037 };
39038
39039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39041 if (SWIG_arg_fail(1)) SWIG_fail;
39042 arg2 = obj1;
39043 if (obj2) {
39044 {
39045 arg3 = (int)(SWIG_As_int(obj2));
39046 if (SWIG_arg_fail(3)) SWIG_fail;
39047 }
39048 }
39049 if (obj3) {
39050 {
39051 arg4 = (int)(SWIG_As_int(obj3));
39052 if (SWIG_arg_fail(4)) SWIG_fail;
39053 }
39054 }
39055 if (obj4) {
39056 {
39057 arg5 = (int)(SWIG_As_int(obj4));
39058 if (SWIG_arg_fail(5)) SWIG_fail;
39059 }
39060 }
39061 if (obj5) {
39062 arg6 = obj5;
39063 }
39064 {
39065 PyThreadState* __tstate = wxPyBeginAllowThreads();
39066 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39067
39068 wxPyEndAllowThreads(__tstate);
39069 if (PyErr_Occurred()) SWIG_fail;
39070 }
39071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39072 return resultobj;
39073 fail:
39074 return NULL;
39075 }
39076
39077
39078 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39079 PyObject *resultobj;
39080 wxSizer *arg1 = (wxSizer *) 0 ;
39081 int arg2 ;
39082 PyObject *arg3 = (PyObject *) 0 ;
39083 int arg4 = (int) 0 ;
39084 int arg5 = (int) 0 ;
39085 int arg6 = (int) 0 ;
39086 PyObject *arg7 = (PyObject *) NULL ;
39087 wxSizerItem *result;
39088 PyObject * obj0 = 0 ;
39089 PyObject * obj1 = 0 ;
39090 PyObject * obj2 = 0 ;
39091 PyObject * obj3 = 0 ;
39092 PyObject * obj4 = 0 ;
39093 PyObject * obj5 = 0 ;
39094 PyObject * obj6 = 0 ;
39095 char *kwnames[] = {
39096 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39097 };
39098
39099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39101 if (SWIG_arg_fail(1)) SWIG_fail;
39102 {
39103 arg2 = (int)(SWIG_As_int(obj1));
39104 if (SWIG_arg_fail(2)) SWIG_fail;
39105 }
39106 arg3 = obj2;
39107 if (obj3) {
39108 {
39109 arg4 = (int)(SWIG_As_int(obj3));
39110 if (SWIG_arg_fail(4)) SWIG_fail;
39111 }
39112 }
39113 if (obj4) {
39114 {
39115 arg5 = (int)(SWIG_As_int(obj4));
39116 if (SWIG_arg_fail(5)) SWIG_fail;
39117 }
39118 }
39119 if (obj5) {
39120 {
39121 arg6 = (int)(SWIG_As_int(obj5));
39122 if (SWIG_arg_fail(6)) SWIG_fail;
39123 }
39124 }
39125 if (obj6) {
39126 arg7 = obj6;
39127 }
39128 {
39129 PyThreadState* __tstate = wxPyBeginAllowThreads();
39130 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39131
39132 wxPyEndAllowThreads(__tstate);
39133 if (PyErr_Occurred()) SWIG_fail;
39134 }
39135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39136 return resultobj;
39137 fail:
39138 return NULL;
39139 }
39140
39141
39142 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39143 PyObject *resultobj;
39144 wxSizer *arg1 = (wxSizer *) 0 ;
39145 PyObject *arg2 = (PyObject *) 0 ;
39146 int arg3 = (int) 0 ;
39147 int arg4 = (int) 0 ;
39148 int arg5 = (int) 0 ;
39149 PyObject *arg6 = (PyObject *) NULL ;
39150 wxSizerItem *result;
39151 PyObject * obj0 = 0 ;
39152 PyObject * obj1 = 0 ;
39153 PyObject * obj2 = 0 ;
39154 PyObject * obj3 = 0 ;
39155 PyObject * obj4 = 0 ;
39156 PyObject * obj5 = 0 ;
39157 char *kwnames[] = {
39158 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39159 };
39160
39161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39163 if (SWIG_arg_fail(1)) SWIG_fail;
39164 arg2 = obj1;
39165 if (obj2) {
39166 {
39167 arg3 = (int)(SWIG_As_int(obj2));
39168 if (SWIG_arg_fail(3)) SWIG_fail;
39169 }
39170 }
39171 if (obj3) {
39172 {
39173 arg4 = (int)(SWIG_As_int(obj3));
39174 if (SWIG_arg_fail(4)) SWIG_fail;
39175 }
39176 }
39177 if (obj4) {
39178 {
39179 arg5 = (int)(SWIG_As_int(obj4));
39180 if (SWIG_arg_fail(5)) SWIG_fail;
39181 }
39182 }
39183 if (obj5) {
39184 arg6 = obj5;
39185 }
39186 {
39187 PyThreadState* __tstate = wxPyBeginAllowThreads();
39188 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39189
39190 wxPyEndAllowThreads(__tstate);
39191 if (PyErr_Occurred()) SWIG_fail;
39192 }
39193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39194 return resultobj;
39195 fail:
39196 return NULL;
39197 }
39198
39199
39200 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39201 PyObject *resultobj;
39202 wxSizer *arg1 = (wxSizer *) 0 ;
39203 PyObject *arg2 = (PyObject *) 0 ;
39204 bool result;
39205 PyObject * obj0 = 0 ;
39206 PyObject * obj1 = 0 ;
39207 char *kwnames[] = {
39208 (char *) "self",(char *) "item", NULL
39209 };
39210
39211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39213 if (SWIG_arg_fail(1)) SWIG_fail;
39214 arg2 = obj1;
39215 {
39216 PyThreadState* __tstate = wxPyBeginAllowThreads();
39217 result = (bool)wxSizer_Remove(arg1,arg2);
39218
39219 wxPyEndAllowThreads(__tstate);
39220 if (PyErr_Occurred()) SWIG_fail;
39221 }
39222 {
39223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39224 }
39225 return resultobj;
39226 fail:
39227 return NULL;
39228 }
39229
39230
39231 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39232 PyObject *resultobj;
39233 wxSizer *arg1 = (wxSizer *) 0 ;
39234 PyObject *arg2 = (PyObject *) 0 ;
39235 bool result;
39236 PyObject * obj0 = 0 ;
39237 PyObject * obj1 = 0 ;
39238 char *kwnames[] = {
39239 (char *) "self",(char *) "item", NULL
39240 };
39241
39242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39244 if (SWIG_arg_fail(1)) SWIG_fail;
39245 arg2 = obj1;
39246 {
39247 PyThreadState* __tstate = wxPyBeginAllowThreads();
39248 result = (bool)wxSizer_Detach(arg1,arg2);
39249
39250 wxPyEndAllowThreads(__tstate);
39251 if (PyErr_Occurred()) SWIG_fail;
39252 }
39253 {
39254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39255 }
39256 return resultobj;
39257 fail:
39258 return NULL;
39259 }
39260
39261
39262 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39263 PyObject *resultobj;
39264 wxSizer *arg1 = (wxSizer *) 0 ;
39265 PyObject *arg2 = (PyObject *) 0 ;
39266 wxSizerItem *result;
39267 PyObject * obj0 = 0 ;
39268 PyObject * obj1 = 0 ;
39269 char *kwnames[] = {
39270 (char *) "self",(char *) "item", NULL
39271 };
39272
39273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39275 if (SWIG_arg_fail(1)) SWIG_fail;
39276 arg2 = obj1;
39277 {
39278 PyThreadState* __tstate = wxPyBeginAllowThreads();
39279 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39280
39281 wxPyEndAllowThreads(__tstate);
39282 if (PyErr_Occurred()) SWIG_fail;
39283 }
39284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39285 return resultobj;
39286 fail:
39287 return NULL;
39288 }
39289
39290
39291 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39292 PyObject *resultobj;
39293 wxSizer *arg1 = (wxSizer *) 0 ;
39294 PyObject *arg2 = (PyObject *) 0 ;
39295 wxSize *arg3 = 0 ;
39296 wxSize temp3 ;
39297 PyObject * obj0 = 0 ;
39298 PyObject * obj1 = 0 ;
39299 PyObject * obj2 = 0 ;
39300 char *kwnames[] = {
39301 (char *) "self",(char *) "item",(char *) "size", NULL
39302 };
39303
39304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39306 if (SWIG_arg_fail(1)) SWIG_fail;
39307 arg2 = obj1;
39308 {
39309 arg3 = &temp3;
39310 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39311 }
39312 {
39313 PyThreadState* __tstate = wxPyBeginAllowThreads();
39314 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39315
39316 wxPyEndAllowThreads(__tstate);
39317 if (PyErr_Occurred()) SWIG_fail;
39318 }
39319 Py_INCREF(Py_None); resultobj = Py_None;
39320 return resultobj;
39321 fail:
39322 return NULL;
39323 }
39324
39325
39326 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39327 PyObject *resultobj;
39328 wxSizer *arg1 = (wxSizer *) 0 ;
39329 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39330 wxSizerItem *result;
39331 PyObject * obj0 = 0 ;
39332 PyObject * obj1 = 0 ;
39333 char *kwnames[] = {
39334 (char *) "self",(char *) "item", NULL
39335 };
39336
39337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39339 if (SWIG_arg_fail(1)) SWIG_fail;
39340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39341 if (SWIG_arg_fail(2)) SWIG_fail;
39342 {
39343 PyThreadState* __tstate = wxPyBeginAllowThreads();
39344 result = (wxSizerItem *)(arg1)->Add(arg2);
39345
39346 wxPyEndAllowThreads(__tstate);
39347 if (PyErr_Occurred()) SWIG_fail;
39348 }
39349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39350 return resultobj;
39351 fail:
39352 return NULL;
39353 }
39354
39355
39356 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39357 PyObject *resultobj;
39358 wxSizer *arg1 = (wxSizer *) 0 ;
39359 size_t arg2 ;
39360 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39361 wxSizerItem *result;
39362 PyObject * obj0 = 0 ;
39363 PyObject * obj1 = 0 ;
39364 PyObject * obj2 = 0 ;
39365 char *kwnames[] = {
39366 (char *) "self",(char *) "index",(char *) "item", NULL
39367 };
39368
39369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39371 if (SWIG_arg_fail(1)) SWIG_fail;
39372 {
39373 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39374 if (SWIG_arg_fail(2)) SWIG_fail;
39375 }
39376 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39377 if (SWIG_arg_fail(3)) SWIG_fail;
39378 {
39379 PyThreadState* __tstate = wxPyBeginAllowThreads();
39380 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39381
39382 wxPyEndAllowThreads(__tstate);
39383 if (PyErr_Occurred()) SWIG_fail;
39384 }
39385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39386 return resultobj;
39387 fail:
39388 return NULL;
39389 }
39390
39391
39392 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39393 PyObject *resultobj;
39394 wxSizer *arg1 = (wxSizer *) 0 ;
39395 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39396 wxSizerItem *result;
39397 PyObject * obj0 = 0 ;
39398 PyObject * obj1 = 0 ;
39399 char *kwnames[] = {
39400 (char *) "self",(char *) "item", NULL
39401 };
39402
39403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39405 if (SWIG_arg_fail(1)) SWIG_fail;
39406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39407 if (SWIG_arg_fail(2)) SWIG_fail;
39408 {
39409 PyThreadState* __tstate = wxPyBeginAllowThreads();
39410 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39411
39412 wxPyEndAllowThreads(__tstate);
39413 if (PyErr_Occurred()) SWIG_fail;
39414 }
39415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39416 return resultobj;
39417 fail:
39418 return NULL;
39419 }
39420
39421
39422 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39423 PyObject *resultobj;
39424 wxSizer *arg1 = (wxSizer *) 0 ;
39425 int arg2 ;
39426 int arg3 ;
39427 int arg4 ;
39428 int arg5 ;
39429 PyObject * obj0 = 0 ;
39430 PyObject * obj1 = 0 ;
39431 PyObject * obj2 = 0 ;
39432 PyObject * obj3 = 0 ;
39433 PyObject * obj4 = 0 ;
39434 char *kwnames[] = {
39435 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39436 };
39437
39438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39440 if (SWIG_arg_fail(1)) SWIG_fail;
39441 {
39442 arg2 = (int)(SWIG_As_int(obj1));
39443 if (SWIG_arg_fail(2)) SWIG_fail;
39444 }
39445 {
39446 arg3 = (int)(SWIG_As_int(obj2));
39447 if (SWIG_arg_fail(3)) SWIG_fail;
39448 }
39449 {
39450 arg4 = (int)(SWIG_As_int(obj3));
39451 if (SWIG_arg_fail(4)) SWIG_fail;
39452 }
39453 {
39454 arg5 = (int)(SWIG_As_int(obj4));
39455 if (SWIG_arg_fail(5)) SWIG_fail;
39456 }
39457 {
39458 PyThreadState* __tstate = wxPyBeginAllowThreads();
39459 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39460
39461 wxPyEndAllowThreads(__tstate);
39462 if (PyErr_Occurred()) SWIG_fail;
39463 }
39464 Py_INCREF(Py_None); resultobj = Py_None;
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39472 PyObject *resultobj;
39473 wxSizer *arg1 = (wxSizer *) 0 ;
39474 wxSize *arg2 = 0 ;
39475 wxSize temp2 ;
39476 PyObject * obj0 = 0 ;
39477 PyObject * obj1 = 0 ;
39478 char *kwnames[] = {
39479 (char *) "self",(char *) "size", NULL
39480 };
39481
39482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39484 if (SWIG_arg_fail(1)) SWIG_fail;
39485 {
39486 arg2 = &temp2;
39487 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39488 }
39489 {
39490 PyThreadState* __tstate = wxPyBeginAllowThreads();
39491 (arg1)->SetMinSize((wxSize const &)*arg2);
39492
39493 wxPyEndAllowThreads(__tstate);
39494 if (PyErr_Occurred()) SWIG_fail;
39495 }
39496 Py_INCREF(Py_None); resultobj = Py_None;
39497 return resultobj;
39498 fail:
39499 return NULL;
39500 }
39501
39502
39503 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39504 PyObject *resultobj;
39505 wxSizer *arg1 = (wxSizer *) 0 ;
39506 wxSize result;
39507 PyObject * obj0 = 0 ;
39508 char *kwnames[] = {
39509 (char *) "self", NULL
39510 };
39511
39512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39514 if (SWIG_arg_fail(1)) SWIG_fail;
39515 {
39516 PyThreadState* __tstate = wxPyBeginAllowThreads();
39517 result = (arg1)->GetSize();
39518
39519 wxPyEndAllowThreads(__tstate);
39520 if (PyErr_Occurred()) SWIG_fail;
39521 }
39522 {
39523 wxSize * resultptr;
39524 resultptr = new wxSize((wxSize &)(result));
39525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39526 }
39527 return resultobj;
39528 fail:
39529 return NULL;
39530 }
39531
39532
39533 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39534 PyObject *resultobj;
39535 wxSizer *arg1 = (wxSizer *) 0 ;
39536 wxPoint result;
39537 PyObject * obj0 = 0 ;
39538 char *kwnames[] = {
39539 (char *) "self", NULL
39540 };
39541
39542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39544 if (SWIG_arg_fail(1)) SWIG_fail;
39545 {
39546 PyThreadState* __tstate = wxPyBeginAllowThreads();
39547 result = (arg1)->GetPosition();
39548
39549 wxPyEndAllowThreads(__tstate);
39550 if (PyErr_Occurred()) SWIG_fail;
39551 }
39552 {
39553 wxPoint * resultptr;
39554 resultptr = new wxPoint((wxPoint &)(result));
39555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39556 }
39557 return resultobj;
39558 fail:
39559 return NULL;
39560 }
39561
39562
39563 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39564 PyObject *resultobj;
39565 wxSizer *arg1 = (wxSizer *) 0 ;
39566 wxSize result;
39567 PyObject * obj0 = 0 ;
39568 char *kwnames[] = {
39569 (char *) "self", NULL
39570 };
39571
39572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39574 if (SWIG_arg_fail(1)) SWIG_fail;
39575 {
39576 PyThreadState* __tstate = wxPyBeginAllowThreads();
39577 result = (arg1)->GetMinSize();
39578
39579 wxPyEndAllowThreads(__tstate);
39580 if (PyErr_Occurred()) SWIG_fail;
39581 }
39582 {
39583 wxSize * resultptr;
39584 resultptr = new wxSize((wxSize &)(result));
39585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39586 }
39587 return resultobj;
39588 fail:
39589 return NULL;
39590 }
39591
39592
39593 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39594 PyObject *resultobj;
39595 wxSizer *arg1 = (wxSizer *) 0 ;
39596 PyObject * obj0 = 0 ;
39597 char *kwnames[] = {
39598 (char *) "self", NULL
39599 };
39600
39601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39603 if (SWIG_arg_fail(1)) SWIG_fail;
39604 {
39605 PyThreadState* __tstate = wxPyBeginAllowThreads();
39606 (arg1)->RecalcSizes();
39607
39608 wxPyEndAllowThreads(__tstate);
39609 if (PyErr_Occurred()) SWIG_fail;
39610 }
39611 Py_INCREF(Py_None); resultobj = Py_None;
39612 return resultobj;
39613 fail:
39614 return NULL;
39615 }
39616
39617
39618 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39619 PyObject *resultobj;
39620 wxSizer *arg1 = (wxSizer *) 0 ;
39621 wxSize result;
39622 PyObject * obj0 = 0 ;
39623 char *kwnames[] = {
39624 (char *) "self", NULL
39625 };
39626
39627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39629 if (SWIG_arg_fail(1)) SWIG_fail;
39630 {
39631 PyThreadState* __tstate = wxPyBeginAllowThreads();
39632 result = (arg1)->CalcMin();
39633
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 {
39638 wxSize * resultptr;
39639 resultptr = new wxSize((wxSize &)(result));
39640 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39641 }
39642 return resultobj;
39643 fail:
39644 return NULL;
39645 }
39646
39647
39648 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39649 PyObject *resultobj;
39650 wxSizer *arg1 = (wxSizer *) 0 ;
39651 PyObject * obj0 = 0 ;
39652 char *kwnames[] = {
39653 (char *) "self", NULL
39654 };
39655
39656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39658 if (SWIG_arg_fail(1)) SWIG_fail;
39659 {
39660 PyThreadState* __tstate = wxPyBeginAllowThreads();
39661 (arg1)->Layout();
39662
39663 wxPyEndAllowThreads(__tstate);
39664 if (PyErr_Occurred()) SWIG_fail;
39665 }
39666 Py_INCREF(Py_None); resultobj = Py_None;
39667 return resultobj;
39668 fail:
39669 return NULL;
39670 }
39671
39672
39673 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39674 PyObject *resultobj;
39675 wxSizer *arg1 = (wxSizer *) 0 ;
39676 wxWindow *arg2 = (wxWindow *) 0 ;
39677 wxSize result;
39678 PyObject * obj0 = 0 ;
39679 PyObject * obj1 = 0 ;
39680 char *kwnames[] = {
39681 (char *) "self",(char *) "window", NULL
39682 };
39683
39684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39686 if (SWIG_arg_fail(1)) SWIG_fail;
39687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39688 if (SWIG_arg_fail(2)) SWIG_fail;
39689 {
39690 PyThreadState* __tstate = wxPyBeginAllowThreads();
39691 result = (arg1)->Fit(arg2);
39692
39693 wxPyEndAllowThreads(__tstate);
39694 if (PyErr_Occurred()) SWIG_fail;
39695 }
39696 {
39697 wxSize * resultptr;
39698 resultptr = new wxSize((wxSize &)(result));
39699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39700 }
39701 return resultobj;
39702 fail:
39703 return NULL;
39704 }
39705
39706
39707 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39708 PyObject *resultobj;
39709 wxSizer *arg1 = (wxSizer *) 0 ;
39710 wxWindow *arg2 = (wxWindow *) 0 ;
39711 PyObject * obj0 = 0 ;
39712 PyObject * obj1 = 0 ;
39713 char *kwnames[] = {
39714 (char *) "self",(char *) "window", NULL
39715 };
39716
39717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39719 if (SWIG_arg_fail(1)) SWIG_fail;
39720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39721 if (SWIG_arg_fail(2)) SWIG_fail;
39722 {
39723 PyThreadState* __tstate = wxPyBeginAllowThreads();
39724 (arg1)->FitInside(arg2);
39725
39726 wxPyEndAllowThreads(__tstate);
39727 if (PyErr_Occurred()) SWIG_fail;
39728 }
39729 Py_INCREF(Py_None); resultobj = Py_None;
39730 return resultobj;
39731 fail:
39732 return NULL;
39733 }
39734
39735
39736 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39737 PyObject *resultobj;
39738 wxSizer *arg1 = (wxSizer *) 0 ;
39739 wxWindow *arg2 = (wxWindow *) 0 ;
39740 PyObject * obj0 = 0 ;
39741 PyObject * obj1 = 0 ;
39742 char *kwnames[] = {
39743 (char *) "self",(char *) "window", NULL
39744 };
39745
39746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39748 if (SWIG_arg_fail(1)) SWIG_fail;
39749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39750 if (SWIG_arg_fail(2)) SWIG_fail;
39751 {
39752 PyThreadState* __tstate = wxPyBeginAllowThreads();
39753 (arg1)->SetSizeHints(arg2);
39754
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 Py_INCREF(Py_None); resultobj = Py_None;
39759 return resultobj;
39760 fail:
39761 return NULL;
39762 }
39763
39764
39765 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39766 PyObject *resultobj;
39767 wxSizer *arg1 = (wxSizer *) 0 ;
39768 wxWindow *arg2 = (wxWindow *) 0 ;
39769 PyObject * obj0 = 0 ;
39770 PyObject * obj1 = 0 ;
39771 char *kwnames[] = {
39772 (char *) "self",(char *) "window", NULL
39773 };
39774
39775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39777 if (SWIG_arg_fail(1)) SWIG_fail;
39778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39779 if (SWIG_arg_fail(2)) SWIG_fail;
39780 {
39781 PyThreadState* __tstate = wxPyBeginAllowThreads();
39782 (arg1)->SetVirtualSizeHints(arg2);
39783
39784 wxPyEndAllowThreads(__tstate);
39785 if (PyErr_Occurred()) SWIG_fail;
39786 }
39787 Py_INCREF(Py_None); resultobj = Py_None;
39788 return resultobj;
39789 fail:
39790 return NULL;
39791 }
39792
39793
39794 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39795 PyObject *resultobj;
39796 wxSizer *arg1 = (wxSizer *) 0 ;
39797 bool arg2 = (bool) false ;
39798 PyObject * obj0 = 0 ;
39799 PyObject * obj1 = 0 ;
39800 char *kwnames[] = {
39801 (char *) "self",(char *) "deleteWindows", NULL
39802 };
39803
39804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39806 if (SWIG_arg_fail(1)) SWIG_fail;
39807 if (obj1) {
39808 {
39809 arg2 = (bool)(SWIG_As_bool(obj1));
39810 if (SWIG_arg_fail(2)) SWIG_fail;
39811 }
39812 }
39813 {
39814 PyThreadState* __tstate = wxPyBeginAllowThreads();
39815 (arg1)->Clear(arg2);
39816
39817 wxPyEndAllowThreads(__tstate);
39818 if (PyErr_Occurred()) SWIG_fail;
39819 }
39820 Py_INCREF(Py_None); resultobj = Py_None;
39821 return resultobj;
39822 fail:
39823 return NULL;
39824 }
39825
39826
39827 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39828 PyObject *resultobj;
39829 wxSizer *arg1 = (wxSizer *) 0 ;
39830 PyObject * obj0 = 0 ;
39831 char *kwnames[] = {
39832 (char *) "self", NULL
39833 };
39834
39835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39837 if (SWIG_arg_fail(1)) SWIG_fail;
39838 {
39839 PyThreadState* __tstate = wxPyBeginAllowThreads();
39840 (arg1)->DeleteWindows();
39841
39842 wxPyEndAllowThreads(__tstate);
39843 if (PyErr_Occurred()) SWIG_fail;
39844 }
39845 Py_INCREF(Py_None); resultobj = Py_None;
39846 return resultobj;
39847 fail:
39848 return NULL;
39849 }
39850
39851
39852 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39853 PyObject *resultobj;
39854 wxSizer *arg1 = (wxSizer *) 0 ;
39855 PyObject *result;
39856 PyObject * obj0 = 0 ;
39857 char *kwnames[] = {
39858 (char *) "self", NULL
39859 };
39860
39861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39863 if (SWIG_arg_fail(1)) SWIG_fail;
39864 {
39865 PyThreadState* __tstate = wxPyBeginAllowThreads();
39866 result = (PyObject *)wxSizer_GetChildren(arg1);
39867
39868 wxPyEndAllowThreads(__tstate);
39869 if (PyErr_Occurred()) SWIG_fail;
39870 }
39871 resultobj = result;
39872 return resultobj;
39873 fail:
39874 return NULL;
39875 }
39876
39877
39878 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39879 PyObject *resultobj;
39880 wxSizer *arg1 = (wxSizer *) 0 ;
39881 PyObject *arg2 = (PyObject *) 0 ;
39882 bool arg3 = (bool) true ;
39883 bool arg4 = (bool) false ;
39884 bool result;
39885 PyObject * obj0 = 0 ;
39886 PyObject * obj1 = 0 ;
39887 PyObject * obj2 = 0 ;
39888 PyObject * obj3 = 0 ;
39889 char *kwnames[] = {
39890 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39891 };
39892
39893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39895 if (SWIG_arg_fail(1)) SWIG_fail;
39896 arg2 = obj1;
39897 if (obj2) {
39898 {
39899 arg3 = (bool)(SWIG_As_bool(obj2));
39900 if (SWIG_arg_fail(3)) SWIG_fail;
39901 }
39902 }
39903 if (obj3) {
39904 {
39905 arg4 = (bool)(SWIG_As_bool(obj3));
39906 if (SWIG_arg_fail(4)) SWIG_fail;
39907 }
39908 }
39909 {
39910 PyThreadState* __tstate = wxPyBeginAllowThreads();
39911 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39912
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 {
39917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39918 }
39919 return resultobj;
39920 fail:
39921 return NULL;
39922 }
39923
39924
39925 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39926 PyObject *resultobj;
39927 wxSizer *arg1 = (wxSizer *) 0 ;
39928 PyObject *arg2 = (PyObject *) 0 ;
39929 bool result;
39930 PyObject * obj0 = 0 ;
39931 PyObject * obj1 = 0 ;
39932 char *kwnames[] = {
39933 (char *) "self",(char *) "item", NULL
39934 };
39935
39936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39938 if (SWIG_arg_fail(1)) SWIG_fail;
39939 arg2 = obj1;
39940 {
39941 PyThreadState* __tstate = wxPyBeginAllowThreads();
39942 result = (bool)wxSizer_IsShown(arg1,arg2);
39943
39944 wxPyEndAllowThreads(__tstate);
39945 if (PyErr_Occurred()) SWIG_fail;
39946 }
39947 {
39948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39949 }
39950 return resultobj;
39951 fail:
39952 return NULL;
39953 }
39954
39955
39956 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39957 PyObject *resultobj;
39958 wxSizer *arg1 = (wxSizer *) 0 ;
39959 bool arg2 ;
39960 PyObject * obj0 = 0 ;
39961 PyObject * obj1 = 0 ;
39962 char *kwnames[] = {
39963 (char *) "self",(char *) "show", NULL
39964 };
39965
39966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39968 if (SWIG_arg_fail(1)) SWIG_fail;
39969 {
39970 arg2 = (bool)(SWIG_As_bool(obj1));
39971 if (SWIG_arg_fail(2)) SWIG_fail;
39972 }
39973 {
39974 PyThreadState* __tstate = wxPyBeginAllowThreads();
39975 (arg1)->ShowItems(arg2);
39976
39977 wxPyEndAllowThreads(__tstate);
39978 if (PyErr_Occurred()) SWIG_fail;
39979 }
39980 Py_INCREF(Py_None); resultobj = Py_None;
39981 return resultobj;
39982 fail:
39983 return NULL;
39984 }
39985
39986
39987 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39988 PyObject *obj;
39989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39990 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39991 Py_INCREF(obj);
39992 return Py_BuildValue((char *)"");
39993 }
39994 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39995 PyObject *resultobj;
39996 wxPySizer *result;
39997 char *kwnames[] = {
39998 NULL
39999 };
40000
40001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40002 {
40003 PyThreadState* __tstate = wxPyBeginAllowThreads();
40004 result = (wxPySizer *)new wxPySizer();
40005
40006 wxPyEndAllowThreads(__tstate);
40007 if (PyErr_Occurred()) SWIG_fail;
40008 }
40009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40010 return resultobj;
40011 fail:
40012 return NULL;
40013 }
40014
40015
40016 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40017 PyObject *resultobj;
40018 wxPySizer *arg1 = (wxPySizer *) 0 ;
40019 PyObject *arg2 = (PyObject *) 0 ;
40020 PyObject *arg3 = (PyObject *) 0 ;
40021 PyObject * obj0 = 0 ;
40022 PyObject * obj1 = 0 ;
40023 PyObject * obj2 = 0 ;
40024 char *kwnames[] = {
40025 (char *) "self",(char *) "self",(char *) "_class", NULL
40026 };
40027
40028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40030 if (SWIG_arg_fail(1)) SWIG_fail;
40031 arg2 = obj1;
40032 arg3 = obj2;
40033 {
40034 PyThreadState* __tstate = wxPyBeginAllowThreads();
40035 (arg1)->_setCallbackInfo(arg2,arg3);
40036
40037 wxPyEndAllowThreads(__tstate);
40038 if (PyErr_Occurred()) SWIG_fail;
40039 }
40040 Py_INCREF(Py_None); resultobj = Py_None;
40041 return resultobj;
40042 fail:
40043 return NULL;
40044 }
40045
40046
40047 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40048 PyObject *obj;
40049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40050 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40051 Py_INCREF(obj);
40052 return Py_BuildValue((char *)"");
40053 }
40054 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40055 PyObject *resultobj;
40056 int arg1 = (int) wxHORIZONTAL ;
40057 wxBoxSizer *result;
40058 PyObject * obj0 = 0 ;
40059 char *kwnames[] = {
40060 (char *) "orient", NULL
40061 };
40062
40063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40064 if (obj0) {
40065 {
40066 arg1 = (int)(SWIG_As_int(obj0));
40067 if (SWIG_arg_fail(1)) SWIG_fail;
40068 }
40069 }
40070 {
40071 PyThreadState* __tstate = wxPyBeginAllowThreads();
40072 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40073
40074 wxPyEndAllowThreads(__tstate);
40075 if (PyErr_Occurred()) SWIG_fail;
40076 }
40077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40078 return resultobj;
40079 fail:
40080 return NULL;
40081 }
40082
40083
40084 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40085 PyObject *resultobj;
40086 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40087 int result;
40088 PyObject * obj0 = 0 ;
40089 char *kwnames[] = {
40090 (char *) "self", NULL
40091 };
40092
40093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40095 if (SWIG_arg_fail(1)) SWIG_fail;
40096 {
40097 PyThreadState* __tstate = wxPyBeginAllowThreads();
40098 result = (int)(arg1)->GetOrientation();
40099
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 {
40104 resultobj = SWIG_From_int((int)(result));
40105 }
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj;
40114 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40115 int arg2 ;
40116 PyObject * obj0 = 0 ;
40117 PyObject * obj1 = 0 ;
40118 char *kwnames[] = {
40119 (char *) "self",(char *) "orient", NULL
40120 };
40121
40122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40124 if (SWIG_arg_fail(1)) SWIG_fail;
40125 {
40126 arg2 = (int)(SWIG_As_int(obj1));
40127 if (SWIG_arg_fail(2)) SWIG_fail;
40128 }
40129 {
40130 PyThreadState* __tstate = wxPyBeginAllowThreads();
40131 (arg1)->SetOrientation(arg2);
40132
40133 wxPyEndAllowThreads(__tstate);
40134 if (PyErr_Occurred()) SWIG_fail;
40135 }
40136 Py_INCREF(Py_None); resultobj = Py_None;
40137 return resultobj;
40138 fail:
40139 return NULL;
40140 }
40141
40142
40143 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40144 PyObject *obj;
40145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40146 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40147 Py_INCREF(obj);
40148 return Py_BuildValue((char *)"");
40149 }
40150 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40151 PyObject *resultobj;
40152 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40153 int arg2 = (int) wxHORIZONTAL ;
40154 wxStaticBoxSizer *result;
40155 PyObject * obj0 = 0 ;
40156 PyObject * obj1 = 0 ;
40157 char *kwnames[] = {
40158 (char *) "box",(char *) "orient", NULL
40159 };
40160
40161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40163 if (SWIG_arg_fail(1)) SWIG_fail;
40164 if (obj1) {
40165 {
40166 arg2 = (int)(SWIG_As_int(obj1));
40167 if (SWIG_arg_fail(2)) SWIG_fail;
40168 }
40169 }
40170 {
40171 PyThreadState* __tstate = wxPyBeginAllowThreads();
40172 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40173
40174 wxPyEndAllowThreads(__tstate);
40175 if (PyErr_Occurred()) SWIG_fail;
40176 }
40177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40178 return resultobj;
40179 fail:
40180 return NULL;
40181 }
40182
40183
40184 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40185 PyObject *resultobj;
40186 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40187 wxStaticBox *result;
40188 PyObject * obj0 = 0 ;
40189 char *kwnames[] = {
40190 (char *) "self", NULL
40191 };
40192
40193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40195 if (SWIG_arg_fail(1)) SWIG_fail;
40196 {
40197 PyThreadState* __tstate = wxPyBeginAllowThreads();
40198 result = (wxStaticBox *)(arg1)->GetStaticBox();
40199
40200 wxPyEndAllowThreads(__tstate);
40201 if (PyErr_Occurred()) SWIG_fail;
40202 }
40203 {
40204 resultobj = wxPyMake_wxObject(result, 0);
40205 }
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40213 PyObject *obj;
40214 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40215 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40216 Py_INCREF(obj);
40217 return Py_BuildValue((char *)"");
40218 }
40219 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40220 PyObject *resultobj;
40221 int arg1 = (int) 1 ;
40222 int arg2 = (int) 0 ;
40223 int arg3 = (int) 0 ;
40224 int arg4 = (int) 0 ;
40225 wxGridSizer *result;
40226 PyObject * obj0 = 0 ;
40227 PyObject * obj1 = 0 ;
40228 PyObject * obj2 = 0 ;
40229 PyObject * obj3 = 0 ;
40230 char *kwnames[] = {
40231 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40232 };
40233
40234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40235 if (obj0) {
40236 {
40237 arg1 = (int)(SWIG_As_int(obj0));
40238 if (SWIG_arg_fail(1)) SWIG_fail;
40239 }
40240 }
40241 if (obj1) {
40242 {
40243 arg2 = (int)(SWIG_As_int(obj1));
40244 if (SWIG_arg_fail(2)) SWIG_fail;
40245 }
40246 }
40247 if (obj2) {
40248 {
40249 arg3 = (int)(SWIG_As_int(obj2));
40250 if (SWIG_arg_fail(3)) SWIG_fail;
40251 }
40252 }
40253 if (obj3) {
40254 {
40255 arg4 = (int)(SWIG_As_int(obj3));
40256 if (SWIG_arg_fail(4)) SWIG_fail;
40257 }
40258 }
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40262
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40267 return resultobj;
40268 fail:
40269 return NULL;
40270 }
40271
40272
40273 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40274 PyObject *resultobj;
40275 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40276 int arg2 ;
40277 PyObject * obj0 = 0 ;
40278 PyObject * obj1 = 0 ;
40279 char *kwnames[] = {
40280 (char *) "self",(char *) "cols", NULL
40281 };
40282
40283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40285 if (SWIG_arg_fail(1)) SWIG_fail;
40286 {
40287 arg2 = (int)(SWIG_As_int(obj1));
40288 if (SWIG_arg_fail(2)) SWIG_fail;
40289 }
40290 {
40291 PyThreadState* __tstate = wxPyBeginAllowThreads();
40292 (arg1)->SetCols(arg2);
40293
40294 wxPyEndAllowThreads(__tstate);
40295 if (PyErr_Occurred()) SWIG_fail;
40296 }
40297 Py_INCREF(Py_None); resultobj = Py_None;
40298 return resultobj;
40299 fail:
40300 return NULL;
40301 }
40302
40303
40304 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40305 PyObject *resultobj;
40306 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40307 int arg2 ;
40308 PyObject * obj0 = 0 ;
40309 PyObject * obj1 = 0 ;
40310 char *kwnames[] = {
40311 (char *) "self",(char *) "rows", NULL
40312 };
40313
40314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40316 if (SWIG_arg_fail(1)) SWIG_fail;
40317 {
40318 arg2 = (int)(SWIG_As_int(obj1));
40319 if (SWIG_arg_fail(2)) SWIG_fail;
40320 }
40321 {
40322 PyThreadState* __tstate = wxPyBeginAllowThreads();
40323 (arg1)->SetRows(arg2);
40324
40325 wxPyEndAllowThreads(__tstate);
40326 if (PyErr_Occurred()) SWIG_fail;
40327 }
40328 Py_INCREF(Py_None); resultobj = Py_None;
40329 return resultobj;
40330 fail:
40331 return NULL;
40332 }
40333
40334
40335 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40336 PyObject *resultobj;
40337 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40338 int arg2 ;
40339 PyObject * obj0 = 0 ;
40340 PyObject * obj1 = 0 ;
40341 char *kwnames[] = {
40342 (char *) "self",(char *) "gap", NULL
40343 };
40344
40345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40347 if (SWIG_arg_fail(1)) SWIG_fail;
40348 {
40349 arg2 = (int)(SWIG_As_int(obj1));
40350 if (SWIG_arg_fail(2)) SWIG_fail;
40351 }
40352 {
40353 PyThreadState* __tstate = wxPyBeginAllowThreads();
40354 (arg1)->SetVGap(arg2);
40355
40356 wxPyEndAllowThreads(__tstate);
40357 if (PyErr_Occurred()) SWIG_fail;
40358 }
40359 Py_INCREF(Py_None); resultobj = Py_None;
40360 return resultobj;
40361 fail:
40362 return NULL;
40363 }
40364
40365
40366 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40367 PyObject *resultobj;
40368 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40369 int arg2 ;
40370 PyObject * obj0 = 0 ;
40371 PyObject * obj1 = 0 ;
40372 char *kwnames[] = {
40373 (char *) "self",(char *) "gap", NULL
40374 };
40375
40376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40378 if (SWIG_arg_fail(1)) SWIG_fail;
40379 {
40380 arg2 = (int)(SWIG_As_int(obj1));
40381 if (SWIG_arg_fail(2)) SWIG_fail;
40382 }
40383 {
40384 PyThreadState* __tstate = wxPyBeginAllowThreads();
40385 (arg1)->SetHGap(arg2);
40386
40387 wxPyEndAllowThreads(__tstate);
40388 if (PyErr_Occurred()) SWIG_fail;
40389 }
40390 Py_INCREF(Py_None); resultobj = Py_None;
40391 return resultobj;
40392 fail:
40393 return NULL;
40394 }
40395
40396
40397 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40398 PyObject *resultobj;
40399 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40400 int result;
40401 PyObject * obj0 = 0 ;
40402 char *kwnames[] = {
40403 (char *) "self", NULL
40404 };
40405
40406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40408 if (SWIG_arg_fail(1)) SWIG_fail;
40409 {
40410 PyThreadState* __tstate = wxPyBeginAllowThreads();
40411 result = (int)(arg1)->GetCols();
40412
40413 wxPyEndAllowThreads(__tstate);
40414 if (PyErr_Occurred()) SWIG_fail;
40415 }
40416 {
40417 resultobj = SWIG_From_int((int)(result));
40418 }
40419 return resultobj;
40420 fail:
40421 return NULL;
40422 }
40423
40424
40425 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40426 PyObject *resultobj;
40427 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40428 int result;
40429 PyObject * obj0 = 0 ;
40430 char *kwnames[] = {
40431 (char *) "self", NULL
40432 };
40433
40434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40436 if (SWIG_arg_fail(1)) SWIG_fail;
40437 {
40438 PyThreadState* __tstate = wxPyBeginAllowThreads();
40439 result = (int)(arg1)->GetRows();
40440
40441 wxPyEndAllowThreads(__tstate);
40442 if (PyErr_Occurred()) SWIG_fail;
40443 }
40444 {
40445 resultobj = SWIG_From_int((int)(result));
40446 }
40447 return resultobj;
40448 fail:
40449 return NULL;
40450 }
40451
40452
40453 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40454 PyObject *resultobj;
40455 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40456 int result;
40457 PyObject * obj0 = 0 ;
40458 char *kwnames[] = {
40459 (char *) "self", NULL
40460 };
40461
40462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40464 if (SWIG_arg_fail(1)) SWIG_fail;
40465 {
40466 PyThreadState* __tstate = wxPyBeginAllowThreads();
40467 result = (int)(arg1)->GetVGap();
40468
40469 wxPyEndAllowThreads(__tstate);
40470 if (PyErr_Occurred()) SWIG_fail;
40471 }
40472 {
40473 resultobj = SWIG_From_int((int)(result));
40474 }
40475 return resultobj;
40476 fail:
40477 return NULL;
40478 }
40479
40480
40481 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40482 PyObject *resultobj;
40483 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40484 int result;
40485 PyObject * obj0 = 0 ;
40486 char *kwnames[] = {
40487 (char *) "self", NULL
40488 };
40489
40490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40492 if (SWIG_arg_fail(1)) SWIG_fail;
40493 {
40494 PyThreadState* __tstate = wxPyBeginAllowThreads();
40495 result = (int)(arg1)->GetHGap();
40496
40497 wxPyEndAllowThreads(__tstate);
40498 if (PyErr_Occurred()) SWIG_fail;
40499 }
40500 {
40501 resultobj = SWIG_From_int((int)(result));
40502 }
40503 return resultobj;
40504 fail:
40505 return NULL;
40506 }
40507
40508
40509 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40510 PyObject *obj;
40511 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40512 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40513 Py_INCREF(obj);
40514 return Py_BuildValue((char *)"");
40515 }
40516 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40517 PyObject *resultobj;
40518 int arg1 = (int) 1 ;
40519 int arg2 = (int) 0 ;
40520 int arg3 = (int) 0 ;
40521 int arg4 = (int) 0 ;
40522 wxFlexGridSizer *result;
40523 PyObject * obj0 = 0 ;
40524 PyObject * obj1 = 0 ;
40525 PyObject * obj2 = 0 ;
40526 PyObject * obj3 = 0 ;
40527 char *kwnames[] = {
40528 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40529 };
40530
40531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40532 if (obj0) {
40533 {
40534 arg1 = (int)(SWIG_As_int(obj0));
40535 if (SWIG_arg_fail(1)) SWIG_fail;
40536 }
40537 }
40538 if (obj1) {
40539 {
40540 arg2 = (int)(SWIG_As_int(obj1));
40541 if (SWIG_arg_fail(2)) SWIG_fail;
40542 }
40543 }
40544 if (obj2) {
40545 {
40546 arg3 = (int)(SWIG_As_int(obj2));
40547 if (SWIG_arg_fail(3)) SWIG_fail;
40548 }
40549 }
40550 if (obj3) {
40551 {
40552 arg4 = (int)(SWIG_As_int(obj3));
40553 if (SWIG_arg_fail(4)) SWIG_fail;
40554 }
40555 }
40556 {
40557 PyThreadState* __tstate = wxPyBeginAllowThreads();
40558 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40559
40560 wxPyEndAllowThreads(__tstate);
40561 if (PyErr_Occurred()) SWIG_fail;
40562 }
40563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40564 return resultobj;
40565 fail:
40566 return NULL;
40567 }
40568
40569
40570 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40571 PyObject *resultobj;
40572 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40573 size_t arg2 ;
40574 int arg3 = (int) 0 ;
40575 PyObject * obj0 = 0 ;
40576 PyObject * obj1 = 0 ;
40577 PyObject * obj2 = 0 ;
40578 char *kwnames[] = {
40579 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40580 };
40581
40582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40584 if (SWIG_arg_fail(1)) SWIG_fail;
40585 {
40586 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40587 if (SWIG_arg_fail(2)) SWIG_fail;
40588 }
40589 if (obj2) {
40590 {
40591 arg3 = (int)(SWIG_As_int(obj2));
40592 if (SWIG_arg_fail(3)) SWIG_fail;
40593 }
40594 }
40595 {
40596 PyThreadState* __tstate = wxPyBeginAllowThreads();
40597 (arg1)->AddGrowableRow(arg2,arg3);
40598
40599 wxPyEndAllowThreads(__tstate);
40600 if (PyErr_Occurred()) SWIG_fail;
40601 }
40602 Py_INCREF(Py_None); resultobj = Py_None;
40603 return resultobj;
40604 fail:
40605 return NULL;
40606 }
40607
40608
40609 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj;
40611 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40612 size_t arg2 ;
40613 PyObject * obj0 = 0 ;
40614 PyObject * obj1 = 0 ;
40615 char *kwnames[] = {
40616 (char *) "self",(char *) "idx", NULL
40617 };
40618
40619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40621 if (SWIG_arg_fail(1)) SWIG_fail;
40622 {
40623 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40624 if (SWIG_arg_fail(2)) SWIG_fail;
40625 }
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 (arg1)->RemoveGrowableRow(arg2);
40629
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 Py_INCREF(Py_None); resultobj = Py_None;
40634 return resultobj;
40635 fail:
40636 return NULL;
40637 }
40638
40639
40640 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40641 PyObject *resultobj;
40642 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40643 size_t arg2 ;
40644 int arg3 = (int) 0 ;
40645 PyObject * obj0 = 0 ;
40646 PyObject * obj1 = 0 ;
40647 PyObject * obj2 = 0 ;
40648 char *kwnames[] = {
40649 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40650 };
40651
40652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40654 if (SWIG_arg_fail(1)) SWIG_fail;
40655 {
40656 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40657 if (SWIG_arg_fail(2)) SWIG_fail;
40658 }
40659 if (obj2) {
40660 {
40661 arg3 = (int)(SWIG_As_int(obj2));
40662 if (SWIG_arg_fail(3)) SWIG_fail;
40663 }
40664 }
40665 {
40666 PyThreadState* __tstate = wxPyBeginAllowThreads();
40667 (arg1)->AddGrowableCol(arg2,arg3);
40668
40669 wxPyEndAllowThreads(__tstate);
40670 if (PyErr_Occurred()) SWIG_fail;
40671 }
40672 Py_INCREF(Py_None); resultobj = Py_None;
40673 return resultobj;
40674 fail:
40675 return NULL;
40676 }
40677
40678
40679 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40680 PyObject *resultobj;
40681 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40682 size_t arg2 ;
40683 PyObject * obj0 = 0 ;
40684 PyObject * obj1 = 0 ;
40685 char *kwnames[] = {
40686 (char *) "self",(char *) "idx", NULL
40687 };
40688
40689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40691 if (SWIG_arg_fail(1)) SWIG_fail;
40692 {
40693 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40694 if (SWIG_arg_fail(2)) SWIG_fail;
40695 }
40696 {
40697 PyThreadState* __tstate = wxPyBeginAllowThreads();
40698 (arg1)->RemoveGrowableCol(arg2);
40699
40700 wxPyEndAllowThreads(__tstate);
40701 if (PyErr_Occurred()) SWIG_fail;
40702 }
40703 Py_INCREF(Py_None); resultobj = Py_None;
40704 return resultobj;
40705 fail:
40706 return NULL;
40707 }
40708
40709
40710 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40711 PyObject *resultobj;
40712 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40713 int arg2 ;
40714 PyObject * obj0 = 0 ;
40715 PyObject * obj1 = 0 ;
40716 char *kwnames[] = {
40717 (char *) "self",(char *) "direction", NULL
40718 };
40719
40720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40722 if (SWIG_arg_fail(1)) SWIG_fail;
40723 {
40724 arg2 = (int)(SWIG_As_int(obj1));
40725 if (SWIG_arg_fail(2)) SWIG_fail;
40726 }
40727 {
40728 PyThreadState* __tstate = wxPyBeginAllowThreads();
40729 (arg1)->SetFlexibleDirection(arg2);
40730
40731 wxPyEndAllowThreads(__tstate);
40732 if (PyErr_Occurred()) SWIG_fail;
40733 }
40734 Py_INCREF(Py_None); resultobj = Py_None;
40735 return resultobj;
40736 fail:
40737 return NULL;
40738 }
40739
40740
40741 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40742 PyObject *resultobj;
40743 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40744 int result;
40745 PyObject * obj0 = 0 ;
40746 char *kwnames[] = {
40747 (char *) "self", NULL
40748 };
40749
40750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40752 if (SWIG_arg_fail(1)) SWIG_fail;
40753 {
40754 PyThreadState* __tstate = wxPyBeginAllowThreads();
40755 result = (int)(arg1)->GetFlexibleDirection();
40756
40757 wxPyEndAllowThreads(__tstate);
40758 if (PyErr_Occurred()) SWIG_fail;
40759 }
40760 {
40761 resultobj = SWIG_From_int((int)(result));
40762 }
40763 return resultobj;
40764 fail:
40765 return NULL;
40766 }
40767
40768
40769 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40770 PyObject *resultobj;
40771 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40772 wxFlexSizerGrowMode arg2 ;
40773 PyObject * obj0 = 0 ;
40774 PyObject * obj1 = 0 ;
40775 char *kwnames[] = {
40776 (char *) "self",(char *) "mode", NULL
40777 };
40778
40779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40781 if (SWIG_arg_fail(1)) SWIG_fail;
40782 {
40783 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40784 if (SWIG_arg_fail(2)) SWIG_fail;
40785 }
40786 {
40787 PyThreadState* __tstate = wxPyBeginAllowThreads();
40788 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40789
40790 wxPyEndAllowThreads(__tstate);
40791 if (PyErr_Occurred()) SWIG_fail;
40792 }
40793 Py_INCREF(Py_None); resultobj = Py_None;
40794 return resultobj;
40795 fail:
40796 return NULL;
40797 }
40798
40799
40800 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40801 PyObject *resultobj;
40802 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40803 wxFlexSizerGrowMode result;
40804 PyObject * obj0 = 0 ;
40805 char *kwnames[] = {
40806 (char *) "self", NULL
40807 };
40808
40809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40811 if (SWIG_arg_fail(1)) SWIG_fail;
40812 {
40813 PyThreadState* __tstate = wxPyBeginAllowThreads();
40814 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40815
40816 wxPyEndAllowThreads(__tstate);
40817 if (PyErr_Occurred()) SWIG_fail;
40818 }
40819 resultobj = SWIG_From_int((result));
40820 return resultobj;
40821 fail:
40822 return NULL;
40823 }
40824
40825
40826 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40827 PyObject *resultobj;
40828 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40829 wxArrayInt *result;
40830 PyObject * obj0 = 0 ;
40831 char *kwnames[] = {
40832 (char *) "self", NULL
40833 };
40834
40835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40837 if (SWIG_arg_fail(1)) SWIG_fail;
40838 {
40839 PyThreadState* __tstate = wxPyBeginAllowThreads();
40840 {
40841 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40842 result = (wxArrayInt *) &_result_ref;
40843 }
40844
40845 wxPyEndAllowThreads(__tstate);
40846 if (PyErr_Occurred()) SWIG_fail;
40847 }
40848 {
40849 resultobj = PyList_New(0);
40850 size_t idx;
40851 for (idx = 0; idx < result->GetCount(); idx += 1) {
40852 PyObject* val = PyInt_FromLong( result->Item(idx) );
40853 PyList_Append(resultobj, val);
40854 Py_DECREF(val);
40855 }
40856 }
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40864 PyObject *resultobj;
40865 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40866 wxArrayInt *result;
40867 PyObject * obj0 = 0 ;
40868 char *kwnames[] = {
40869 (char *) "self", NULL
40870 };
40871
40872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40874 if (SWIG_arg_fail(1)) SWIG_fail;
40875 {
40876 PyThreadState* __tstate = wxPyBeginAllowThreads();
40877 {
40878 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40879 result = (wxArrayInt *) &_result_ref;
40880 }
40881
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 {
40886 resultobj = PyList_New(0);
40887 size_t idx;
40888 for (idx = 0; idx < result->GetCount(); idx += 1) {
40889 PyObject* val = PyInt_FromLong( result->Item(idx) );
40890 PyList_Append(resultobj, val);
40891 Py_DECREF(val);
40892 }
40893 }
40894 return resultobj;
40895 fail:
40896 return NULL;
40897 }
40898
40899
40900 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40901 PyObject *obj;
40902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40903 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40904 Py_INCREF(obj);
40905 return Py_BuildValue((char *)"");
40906 }
40907 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40908 PyObject *resultobj;
40909 wxStdDialogButtonSizer *result;
40910 char *kwnames[] = {
40911 NULL
40912 };
40913
40914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40915 {
40916 PyThreadState* __tstate = wxPyBeginAllowThreads();
40917 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40918
40919 wxPyEndAllowThreads(__tstate);
40920 if (PyErr_Occurred()) SWIG_fail;
40921 }
40922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40923 return resultobj;
40924 fail:
40925 return NULL;
40926 }
40927
40928
40929 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40930 PyObject *resultobj;
40931 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40932 wxButton *arg2 = (wxButton *) 0 ;
40933 PyObject * obj0 = 0 ;
40934 PyObject * obj1 = 0 ;
40935 char *kwnames[] = {
40936 (char *) "self",(char *) "button", NULL
40937 };
40938
40939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40941 if (SWIG_arg_fail(1)) SWIG_fail;
40942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40943 if (SWIG_arg_fail(2)) SWIG_fail;
40944 {
40945 PyThreadState* __tstate = wxPyBeginAllowThreads();
40946 (arg1)->AddButton(arg2);
40947
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 Py_INCREF(Py_None); resultobj = Py_None;
40952 return resultobj;
40953 fail:
40954 return NULL;
40955 }
40956
40957
40958 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
40959 PyObject *resultobj;
40960 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40961 PyObject * obj0 = 0 ;
40962 char *kwnames[] = {
40963 (char *) "self", NULL
40964 };
40965
40966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
40967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40968 if (SWIG_arg_fail(1)) SWIG_fail;
40969 {
40970 PyThreadState* __tstate = wxPyBeginAllowThreads();
40971 (arg1)->Realize();
40972
40973 wxPyEndAllowThreads(__tstate);
40974 if (PyErr_Occurred()) SWIG_fail;
40975 }
40976 Py_INCREF(Py_None); resultobj = Py_None;
40977 return resultobj;
40978 fail:
40979 return NULL;
40980 }
40981
40982
40983 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40984 PyObject *resultobj;
40985 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40986 wxButton *arg2 = (wxButton *) 0 ;
40987 PyObject * obj0 = 0 ;
40988 PyObject * obj1 = 0 ;
40989 char *kwnames[] = {
40990 (char *) "self",(char *) "button", NULL
40991 };
40992
40993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40995 if (SWIG_arg_fail(1)) SWIG_fail;
40996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40997 if (SWIG_arg_fail(2)) SWIG_fail;
40998 {
40999 PyThreadState* __tstate = wxPyBeginAllowThreads();
41000 (arg1)->SetAffirmativeButton(arg2);
41001
41002 wxPyEndAllowThreads(__tstate);
41003 if (PyErr_Occurred()) SWIG_fail;
41004 }
41005 Py_INCREF(Py_None); resultobj = Py_None;
41006 return resultobj;
41007 fail:
41008 return NULL;
41009 }
41010
41011
41012 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41013 PyObject *resultobj;
41014 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41015 wxButton *arg2 = (wxButton *) 0 ;
41016 PyObject * obj0 = 0 ;
41017 PyObject * obj1 = 0 ;
41018 char *kwnames[] = {
41019 (char *) "self",(char *) "button", NULL
41020 };
41021
41022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41024 if (SWIG_arg_fail(1)) SWIG_fail;
41025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41026 if (SWIG_arg_fail(2)) SWIG_fail;
41027 {
41028 PyThreadState* __tstate = wxPyBeginAllowThreads();
41029 (arg1)->SetNegativeButton(arg2);
41030
41031 wxPyEndAllowThreads(__tstate);
41032 if (PyErr_Occurred()) SWIG_fail;
41033 }
41034 Py_INCREF(Py_None); resultobj = Py_None;
41035 return resultobj;
41036 fail:
41037 return NULL;
41038 }
41039
41040
41041 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41042 PyObject *resultobj;
41043 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41044 wxButton *arg2 = (wxButton *) 0 ;
41045 PyObject * obj0 = 0 ;
41046 PyObject * obj1 = 0 ;
41047 char *kwnames[] = {
41048 (char *) "self",(char *) "button", NULL
41049 };
41050
41051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41053 if (SWIG_arg_fail(1)) SWIG_fail;
41054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41055 if (SWIG_arg_fail(2)) SWIG_fail;
41056 {
41057 PyThreadState* __tstate = wxPyBeginAllowThreads();
41058 (arg1)->SetCancelButton(arg2);
41059
41060 wxPyEndAllowThreads(__tstate);
41061 if (PyErr_Occurred()) SWIG_fail;
41062 }
41063 Py_INCREF(Py_None); resultobj = Py_None;
41064 return resultobj;
41065 fail:
41066 return NULL;
41067 }
41068
41069
41070 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41071 PyObject *resultobj;
41072 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41073 wxButton *result;
41074 PyObject * obj0 = 0 ;
41075 char *kwnames[] = {
41076 (char *) "self", NULL
41077 };
41078
41079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41081 if (SWIG_arg_fail(1)) SWIG_fail;
41082 {
41083 PyThreadState* __tstate = wxPyBeginAllowThreads();
41084 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41085
41086 wxPyEndAllowThreads(__tstate);
41087 if (PyErr_Occurred()) SWIG_fail;
41088 }
41089 {
41090 resultobj = wxPyMake_wxObject(result, 0);
41091 }
41092 return resultobj;
41093 fail:
41094 return NULL;
41095 }
41096
41097
41098 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41099 PyObject *resultobj;
41100 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41101 wxButton *result;
41102 PyObject * obj0 = 0 ;
41103 char *kwnames[] = {
41104 (char *) "self", NULL
41105 };
41106
41107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41109 if (SWIG_arg_fail(1)) SWIG_fail;
41110 {
41111 PyThreadState* __tstate = wxPyBeginAllowThreads();
41112 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41113
41114 wxPyEndAllowThreads(__tstate);
41115 if (PyErr_Occurred()) SWIG_fail;
41116 }
41117 {
41118 resultobj = wxPyMake_wxObject(result, 0);
41119 }
41120 return resultobj;
41121 fail:
41122 return NULL;
41123 }
41124
41125
41126 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41127 PyObject *resultobj;
41128 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41129 wxButton *result;
41130 PyObject * obj0 = 0 ;
41131 char *kwnames[] = {
41132 (char *) "self", NULL
41133 };
41134
41135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41137 if (SWIG_arg_fail(1)) SWIG_fail;
41138 {
41139 PyThreadState* __tstate = wxPyBeginAllowThreads();
41140 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41141
41142 wxPyEndAllowThreads(__tstate);
41143 if (PyErr_Occurred()) SWIG_fail;
41144 }
41145 {
41146 resultobj = wxPyMake_wxObject(result, 0);
41147 }
41148 return resultobj;
41149 fail:
41150 return NULL;
41151 }
41152
41153
41154 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41155 PyObject *resultobj;
41156 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41157 wxButton *result;
41158 PyObject * obj0 = 0 ;
41159 char *kwnames[] = {
41160 (char *) "self", NULL
41161 };
41162
41163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41165 if (SWIG_arg_fail(1)) SWIG_fail;
41166 {
41167 PyThreadState* __tstate = wxPyBeginAllowThreads();
41168 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41169
41170 wxPyEndAllowThreads(__tstate);
41171 if (PyErr_Occurred()) SWIG_fail;
41172 }
41173 {
41174 resultobj = wxPyMake_wxObject(result, 0);
41175 }
41176 return resultobj;
41177 fail:
41178 return NULL;
41179 }
41180
41181
41182 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41183 PyObject *resultobj;
41184 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41185 wxButton *result;
41186 PyObject * obj0 = 0 ;
41187 char *kwnames[] = {
41188 (char *) "self", NULL
41189 };
41190
41191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41193 if (SWIG_arg_fail(1)) SWIG_fail;
41194 {
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41197
41198 wxPyEndAllowThreads(__tstate);
41199 if (PyErr_Occurred()) SWIG_fail;
41200 }
41201 {
41202 resultobj = wxPyMake_wxObject(result, 0);
41203 }
41204 return resultobj;
41205 fail:
41206 return NULL;
41207 }
41208
41209
41210 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41211 PyObject *obj;
41212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41213 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41214 Py_INCREF(obj);
41215 return Py_BuildValue((char *)"");
41216 }
41217 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41218 PyObject *resultobj;
41219 int arg1 = (int) 0 ;
41220 int arg2 = (int) 0 ;
41221 wxGBPosition *result;
41222 PyObject * obj0 = 0 ;
41223 PyObject * obj1 = 0 ;
41224 char *kwnames[] = {
41225 (char *) "row",(char *) "col", NULL
41226 };
41227
41228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41229 if (obj0) {
41230 {
41231 arg1 = (int)(SWIG_As_int(obj0));
41232 if (SWIG_arg_fail(1)) SWIG_fail;
41233 }
41234 }
41235 if (obj1) {
41236 {
41237 arg2 = (int)(SWIG_As_int(obj1));
41238 if (SWIG_arg_fail(2)) SWIG_fail;
41239 }
41240 }
41241 {
41242 PyThreadState* __tstate = wxPyBeginAllowThreads();
41243 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41244
41245 wxPyEndAllowThreads(__tstate);
41246 if (PyErr_Occurred()) SWIG_fail;
41247 }
41248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41249 return resultobj;
41250 fail:
41251 return NULL;
41252 }
41253
41254
41255 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41256 PyObject *resultobj;
41257 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41258 int result;
41259 PyObject * obj0 = 0 ;
41260 char *kwnames[] = {
41261 (char *) "self", NULL
41262 };
41263
41264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41266 if (SWIG_arg_fail(1)) SWIG_fail;
41267 {
41268 PyThreadState* __tstate = wxPyBeginAllowThreads();
41269 result = (int)((wxGBPosition const *)arg1)->GetRow();
41270
41271 wxPyEndAllowThreads(__tstate);
41272 if (PyErr_Occurred()) SWIG_fail;
41273 }
41274 {
41275 resultobj = SWIG_From_int((int)(result));
41276 }
41277 return resultobj;
41278 fail:
41279 return NULL;
41280 }
41281
41282
41283 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41284 PyObject *resultobj;
41285 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41286 int result;
41287 PyObject * obj0 = 0 ;
41288 char *kwnames[] = {
41289 (char *) "self", NULL
41290 };
41291
41292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41294 if (SWIG_arg_fail(1)) SWIG_fail;
41295 {
41296 PyThreadState* __tstate = wxPyBeginAllowThreads();
41297 result = (int)((wxGBPosition const *)arg1)->GetCol();
41298
41299 wxPyEndAllowThreads(__tstate);
41300 if (PyErr_Occurred()) SWIG_fail;
41301 }
41302 {
41303 resultobj = SWIG_From_int((int)(result));
41304 }
41305 return resultobj;
41306 fail:
41307 return NULL;
41308 }
41309
41310
41311 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41312 PyObject *resultobj;
41313 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41314 int arg2 ;
41315 PyObject * obj0 = 0 ;
41316 PyObject * obj1 = 0 ;
41317 char *kwnames[] = {
41318 (char *) "self",(char *) "row", NULL
41319 };
41320
41321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41323 if (SWIG_arg_fail(1)) SWIG_fail;
41324 {
41325 arg2 = (int)(SWIG_As_int(obj1));
41326 if (SWIG_arg_fail(2)) SWIG_fail;
41327 }
41328 {
41329 PyThreadState* __tstate = wxPyBeginAllowThreads();
41330 (arg1)->SetRow(arg2);
41331
41332 wxPyEndAllowThreads(__tstate);
41333 if (PyErr_Occurred()) SWIG_fail;
41334 }
41335 Py_INCREF(Py_None); resultobj = Py_None;
41336 return resultobj;
41337 fail:
41338 return NULL;
41339 }
41340
41341
41342 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41343 PyObject *resultobj;
41344 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41345 int arg2 ;
41346 PyObject * obj0 = 0 ;
41347 PyObject * obj1 = 0 ;
41348 char *kwnames[] = {
41349 (char *) "self",(char *) "col", NULL
41350 };
41351
41352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41354 if (SWIG_arg_fail(1)) SWIG_fail;
41355 {
41356 arg2 = (int)(SWIG_As_int(obj1));
41357 if (SWIG_arg_fail(2)) SWIG_fail;
41358 }
41359 {
41360 PyThreadState* __tstate = wxPyBeginAllowThreads();
41361 (arg1)->SetCol(arg2);
41362
41363 wxPyEndAllowThreads(__tstate);
41364 if (PyErr_Occurred()) SWIG_fail;
41365 }
41366 Py_INCREF(Py_None); resultobj = Py_None;
41367 return resultobj;
41368 fail:
41369 return NULL;
41370 }
41371
41372
41373 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41374 PyObject *resultobj;
41375 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41376 wxGBPosition *arg2 = 0 ;
41377 bool result;
41378 wxGBPosition temp2 ;
41379 PyObject * obj0 = 0 ;
41380 PyObject * obj1 = 0 ;
41381 char *kwnames[] = {
41382 (char *) "self",(char *) "other", NULL
41383 };
41384
41385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41387 if (SWIG_arg_fail(1)) SWIG_fail;
41388 {
41389 arg2 = &temp2;
41390 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41391 }
41392 {
41393 PyThreadState* __tstate = wxPyBeginAllowThreads();
41394 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41395
41396 wxPyEndAllowThreads(__tstate);
41397 if (PyErr_Occurred()) SWIG_fail;
41398 }
41399 {
41400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41401 }
41402 return resultobj;
41403 fail:
41404 return NULL;
41405 }
41406
41407
41408 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41409 PyObject *resultobj;
41410 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41411 wxGBPosition *arg2 = 0 ;
41412 bool result;
41413 wxGBPosition temp2 ;
41414 PyObject * obj0 = 0 ;
41415 PyObject * obj1 = 0 ;
41416 char *kwnames[] = {
41417 (char *) "self",(char *) "other", NULL
41418 };
41419
41420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41422 if (SWIG_arg_fail(1)) SWIG_fail;
41423 {
41424 arg2 = &temp2;
41425 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41426 }
41427 {
41428 PyThreadState* __tstate = wxPyBeginAllowThreads();
41429 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41430
41431 wxPyEndAllowThreads(__tstate);
41432 if (PyErr_Occurred()) SWIG_fail;
41433 }
41434 {
41435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41436 }
41437 return resultobj;
41438 fail:
41439 return NULL;
41440 }
41441
41442
41443 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41444 PyObject *resultobj;
41445 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41446 int arg2 = (int) 0 ;
41447 int arg3 = (int) 0 ;
41448 PyObject * obj0 = 0 ;
41449 PyObject * obj1 = 0 ;
41450 PyObject * obj2 = 0 ;
41451 char *kwnames[] = {
41452 (char *) "self",(char *) "row",(char *) "col", NULL
41453 };
41454
41455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41457 if (SWIG_arg_fail(1)) SWIG_fail;
41458 if (obj1) {
41459 {
41460 arg2 = (int)(SWIG_As_int(obj1));
41461 if (SWIG_arg_fail(2)) SWIG_fail;
41462 }
41463 }
41464 if (obj2) {
41465 {
41466 arg3 = (int)(SWIG_As_int(obj2));
41467 if (SWIG_arg_fail(3)) SWIG_fail;
41468 }
41469 }
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 wxGBPosition_Set(arg1,arg2,arg3);
41473
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 Py_INCREF(Py_None); resultobj = Py_None;
41478 return resultobj;
41479 fail:
41480 return NULL;
41481 }
41482
41483
41484 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41485 PyObject *resultobj;
41486 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41487 PyObject *result;
41488 PyObject * obj0 = 0 ;
41489 char *kwnames[] = {
41490 (char *) "self", NULL
41491 };
41492
41493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41495 if (SWIG_arg_fail(1)) SWIG_fail;
41496 {
41497 PyThreadState* __tstate = wxPyBeginAllowThreads();
41498 result = (PyObject *)wxGBPosition_Get(arg1);
41499
41500 wxPyEndAllowThreads(__tstate);
41501 if (PyErr_Occurred()) SWIG_fail;
41502 }
41503 resultobj = result;
41504 return resultobj;
41505 fail:
41506 return NULL;
41507 }
41508
41509
41510 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41511 PyObject *obj;
41512 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41513 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41514 Py_INCREF(obj);
41515 return Py_BuildValue((char *)"");
41516 }
41517 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41518 PyObject *resultobj;
41519 int arg1 = (int) 1 ;
41520 int arg2 = (int) 1 ;
41521 wxGBSpan *result;
41522 PyObject * obj0 = 0 ;
41523 PyObject * obj1 = 0 ;
41524 char *kwnames[] = {
41525 (char *) "rowspan",(char *) "colspan", NULL
41526 };
41527
41528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41529 if (obj0) {
41530 {
41531 arg1 = (int)(SWIG_As_int(obj0));
41532 if (SWIG_arg_fail(1)) SWIG_fail;
41533 }
41534 }
41535 if (obj1) {
41536 {
41537 arg2 = (int)(SWIG_As_int(obj1));
41538 if (SWIG_arg_fail(2)) SWIG_fail;
41539 }
41540 }
41541 {
41542 PyThreadState* __tstate = wxPyBeginAllowThreads();
41543 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41544
41545 wxPyEndAllowThreads(__tstate);
41546 if (PyErr_Occurred()) SWIG_fail;
41547 }
41548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41549 return resultobj;
41550 fail:
41551 return NULL;
41552 }
41553
41554
41555 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41556 PyObject *resultobj;
41557 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41558 int result;
41559 PyObject * obj0 = 0 ;
41560 char *kwnames[] = {
41561 (char *) "self", NULL
41562 };
41563
41564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41566 if (SWIG_arg_fail(1)) SWIG_fail;
41567 {
41568 PyThreadState* __tstate = wxPyBeginAllowThreads();
41569 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41570
41571 wxPyEndAllowThreads(__tstate);
41572 if (PyErr_Occurred()) SWIG_fail;
41573 }
41574 {
41575 resultobj = SWIG_From_int((int)(result));
41576 }
41577 return resultobj;
41578 fail:
41579 return NULL;
41580 }
41581
41582
41583 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41584 PyObject *resultobj;
41585 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41586 int result;
41587 PyObject * obj0 = 0 ;
41588 char *kwnames[] = {
41589 (char *) "self", NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(1)) SWIG_fail;
41595 {
41596 PyThreadState* __tstate = wxPyBeginAllowThreads();
41597 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41598
41599 wxPyEndAllowThreads(__tstate);
41600 if (PyErr_Occurred()) SWIG_fail;
41601 }
41602 {
41603 resultobj = SWIG_From_int((int)(result));
41604 }
41605 return resultobj;
41606 fail:
41607 return NULL;
41608 }
41609
41610
41611 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41612 PyObject *resultobj;
41613 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41614 int arg2 ;
41615 PyObject * obj0 = 0 ;
41616 PyObject * obj1 = 0 ;
41617 char *kwnames[] = {
41618 (char *) "self",(char *) "rowspan", NULL
41619 };
41620
41621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41623 if (SWIG_arg_fail(1)) SWIG_fail;
41624 {
41625 arg2 = (int)(SWIG_As_int(obj1));
41626 if (SWIG_arg_fail(2)) SWIG_fail;
41627 }
41628 {
41629 PyThreadState* __tstate = wxPyBeginAllowThreads();
41630 (arg1)->SetRowspan(arg2);
41631
41632 wxPyEndAllowThreads(__tstate);
41633 if (PyErr_Occurred()) SWIG_fail;
41634 }
41635 Py_INCREF(Py_None); resultobj = Py_None;
41636 return resultobj;
41637 fail:
41638 return NULL;
41639 }
41640
41641
41642 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41643 PyObject *resultobj;
41644 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41645 int arg2 ;
41646 PyObject * obj0 = 0 ;
41647 PyObject * obj1 = 0 ;
41648 char *kwnames[] = {
41649 (char *) "self",(char *) "colspan", NULL
41650 };
41651
41652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41654 if (SWIG_arg_fail(1)) SWIG_fail;
41655 {
41656 arg2 = (int)(SWIG_As_int(obj1));
41657 if (SWIG_arg_fail(2)) SWIG_fail;
41658 }
41659 {
41660 PyThreadState* __tstate = wxPyBeginAllowThreads();
41661 (arg1)->SetColspan(arg2);
41662
41663 wxPyEndAllowThreads(__tstate);
41664 if (PyErr_Occurred()) SWIG_fail;
41665 }
41666 Py_INCREF(Py_None); resultobj = Py_None;
41667 return resultobj;
41668 fail:
41669 return NULL;
41670 }
41671
41672
41673 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41674 PyObject *resultobj;
41675 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41676 wxGBSpan *arg2 = 0 ;
41677 bool result;
41678 wxGBSpan temp2 ;
41679 PyObject * obj0 = 0 ;
41680 PyObject * obj1 = 0 ;
41681 char *kwnames[] = {
41682 (char *) "self",(char *) "other", NULL
41683 };
41684
41685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41687 if (SWIG_arg_fail(1)) SWIG_fail;
41688 {
41689 arg2 = &temp2;
41690 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41691 }
41692 {
41693 PyThreadState* __tstate = wxPyBeginAllowThreads();
41694 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41695
41696 wxPyEndAllowThreads(__tstate);
41697 if (PyErr_Occurred()) SWIG_fail;
41698 }
41699 {
41700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41701 }
41702 return resultobj;
41703 fail:
41704 return NULL;
41705 }
41706
41707
41708 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41709 PyObject *resultobj;
41710 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41711 wxGBSpan *arg2 = 0 ;
41712 bool result;
41713 wxGBSpan temp2 ;
41714 PyObject * obj0 = 0 ;
41715 PyObject * obj1 = 0 ;
41716 char *kwnames[] = {
41717 (char *) "self",(char *) "other", NULL
41718 };
41719
41720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41722 if (SWIG_arg_fail(1)) SWIG_fail;
41723 {
41724 arg2 = &temp2;
41725 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41726 }
41727 {
41728 PyThreadState* __tstate = wxPyBeginAllowThreads();
41729 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41730
41731 wxPyEndAllowThreads(__tstate);
41732 if (PyErr_Occurred()) SWIG_fail;
41733 }
41734 {
41735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41736 }
41737 return resultobj;
41738 fail:
41739 return NULL;
41740 }
41741
41742
41743 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41744 PyObject *resultobj;
41745 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41746 int arg2 = (int) 1 ;
41747 int arg3 = (int) 1 ;
41748 PyObject * obj0 = 0 ;
41749 PyObject * obj1 = 0 ;
41750 PyObject * obj2 = 0 ;
41751 char *kwnames[] = {
41752 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41753 };
41754
41755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41757 if (SWIG_arg_fail(1)) SWIG_fail;
41758 if (obj1) {
41759 {
41760 arg2 = (int)(SWIG_As_int(obj1));
41761 if (SWIG_arg_fail(2)) SWIG_fail;
41762 }
41763 }
41764 if (obj2) {
41765 {
41766 arg3 = (int)(SWIG_As_int(obj2));
41767 if (SWIG_arg_fail(3)) SWIG_fail;
41768 }
41769 }
41770 {
41771 PyThreadState* __tstate = wxPyBeginAllowThreads();
41772 wxGBSpan_Set(arg1,arg2,arg3);
41773
41774 wxPyEndAllowThreads(__tstate);
41775 if (PyErr_Occurred()) SWIG_fail;
41776 }
41777 Py_INCREF(Py_None); resultobj = Py_None;
41778 return resultobj;
41779 fail:
41780 return NULL;
41781 }
41782
41783
41784 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41785 PyObject *resultobj;
41786 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41787 PyObject *result;
41788 PyObject * obj0 = 0 ;
41789 char *kwnames[] = {
41790 (char *) "self", NULL
41791 };
41792
41793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41795 if (SWIG_arg_fail(1)) SWIG_fail;
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 result = (PyObject *)wxGBSpan_Get(arg1);
41799
41800 wxPyEndAllowThreads(__tstate);
41801 if (PyErr_Occurred()) SWIG_fail;
41802 }
41803 resultobj = result;
41804 return resultobj;
41805 fail:
41806 return NULL;
41807 }
41808
41809
41810 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41811 PyObject *obj;
41812 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41813 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41814 Py_INCREF(obj);
41815 return Py_BuildValue((char *)"");
41816 }
41817 static int _wrap_DefaultSpan_set(PyObject *) {
41818 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41819 return 1;
41820 }
41821
41822
41823 static PyObject *_wrap_DefaultSpan_get(void) {
41824 PyObject *pyobj;
41825
41826 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41827 return pyobj;
41828 }
41829
41830
41831 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41832 PyObject *resultobj;
41833 wxGBSizerItem *result;
41834 char *kwnames[] = {
41835 NULL
41836 };
41837
41838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41839 {
41840 PyThreadState* __tstate = wxPyBeginAllowThreads();
41841 result = (wxGBSizerItem *)new wxGBSizerItem();
41842
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41847 return resultobj;
41848 fail:
41849 return NULL;
41850 }
41851
41852
41853 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41854 PyObject *resultobj;
41855 wxWindow *arg1 = (wxWindow *) 0 ;
41856 wxGBPosition *arg2 = 0 ;
41857 wxGBSpan *arg3 = 0 ;
41858 int arg4 ;
41859 int arg5 ;
41860 PyObject *arg6 = (PyObject *) NULL ;
41861 wxGBSizerItem *result;
41862 wxGBPosition temp2 ;
41863 wxGBSpan temp3 ;
41864 PyObject * obj0 = 0 ;
41865 PyObject * obj1 = 0 ;
41866 PyObject * obj2 = 0 ;
41867 PyObject * obj3 = 0 ;
41868 PyObject * obj4 = 0 ;
41869 PyObject * obj5 = 0 ;
41870 char *kwnames[] = {
41871 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41872 };
41873
41874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41876 if (SWIG_arg_fail(1)) SWIG_fail;
41877 {
41878 arg2 = &temp2;
41879 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41880 }
41881 {
41882 arg3 = &temp3;
41883 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41884 }
41885 {
41886 arg4 = (int)(SWIG_As_int(obj3));
41887 if (SWIG_arg_fail(4)) SWIG_fail;
41888 }
41889 {
41890 arg5 = (int)(SWIG_As_int(obj4));
41891 if (SWIG_arg_fail(5)) SWIG_fail;
41892 }
41893 if (obj5) {
41894 arg6 = obj5;
41895 }
41896 {
41897 PyThreadState* __tstate = wxPyBeginAllowThreads();
41898 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41899
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41904 return resultobj;
41905 fail:
41906 return NULL;
41907 }
41908
41909
41910 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41911 PyObject *resultobj;
41912 wxSizer *arg1 = (wxSizer *) 0 ;
41913 wxGBPosition *arg2 = 0 ;
41914 wxGBSpan *arg3 = 0 ;
41915 int arg4 ;
41916 int arg5 ;
41917 PyObject *arg6 = (PyObject *) NULL ;
41918 wxGBSizerItem *result;
41919 wxGBPosition temp2 ;
41920 wxGBSpan temp3 ;
41921 PyObject * obj0 = 0 ;
41922 PyObject * obj1 = 0 ;
41923 PyObject * obj2 = 0 ;
41924 PyObject * obj3 = 0 ;
41925 PyObject * obj4 = 0 ;
41926 PyObject * obj5 = 0 ;
41927 char *kwnames[] = {
41928 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41929 };
41930
41931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41933 if (SWIG_arg_fail(1)) SWIG_fail;
41934 {
41935 arg2 = &temp2;
41936 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41937 }
41938 {
41939 arg3 = &temp3;
41940 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41941 }
41942 {
41943 arg4 = (int)(SWIG_As_int(obj3));
41944 if (SWIG_arg_fail(4)) SWIG_fail;
41945 }
41946 {
41947 arg5 = (int)(SWIG_As_int(obj4));
41948 if (SWIG_arg_fail(5)) SWIG_fail;
41949 }
41950 if (obj5) {
41951 arg6 = obj5;
41952 }
41953 {
41954 PyThreadState* __tstate = wxPyBeginAllowThreads();
41955 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41956
41957 wxPyEndAllowThreads(__tstate);
41958 if (PyErr_Occurred()) SWIG_fail;
41959 }
41960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41961 return resultobj;
41962 fail:
41963 return NULL;
41964 }
41965
41966
41967 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41968 PyObject *resultobj;
41969 int arg1 ;
41970 int arg2 ;
41971 wxGBPosition *arg3 = 0 ;
41972 wxGBSpan *arg4 = 0 ;
41973 int arg5 ;
41974 int arg6 ;
41975 PyObject *arg7 = (PyObject *) NULL ;
41976 wxGBSizerItem *result;
41977 wxGBPosition temp3 ;
41978 wxGBSpan temp4 ;
41979 PyObject * obj0 = 0 ;
41980 PyObject * obj1 = 0 ;
41981 PyObject * obj2 = 0 ;
41982 PyObject * obj3 = 0 ;
41983 PyObject * obj4 = 0 ;
41984 PyObject * obj5 = 0 ;
41985 PyObject * obj6 = 0 ;
41986 char *kwnames[] = {
41987 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41988 };
41989
41990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41991 {
41992 arg1 = (int)(SWIG_As_int(obj0));
41993 if (SWIG_arg_fail(1)) SWIG_fail;
41994 }
41995 {
41996 arg2 = (int)(SWIG_As_int(obj1));
41997 if (SWIG_arg_fail(2)) SWIG_fail;
41998 }
41999 {
42000 arg3 = &temp3;
42001 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42002 }
42003 {
42004 arg4 = &temp4;
42005 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42006 }
42007 {
42008 arg5 = (int)(SWIG_As_int(obj4));
42009 if (SWIG_arg_fail(5)) SWIG_fail;
42010 }
42011 {
42012 arg6 = (int)(SWIG_As_int(obj5));
42013 if (SWIG_arg_fail(6)) SWIG_fail;
42014 }
42015 if (obj6) {
42016 arg7 = obj6;
42017 }
42018 {
42019 PyThreadState* __tstate = wxPyBeginAllowThreads();
42020 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42021
42022 wxPyEndAllowThreads(__tstate);
42023 if (PyErr_Occurred()) SWIG_fail;
42024 }
42025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42026 return resultobj;
42027 fail:
42028 return NULL;
42029 }
42030
42031
42032 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42033 PyObject *resultobj;
42034 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42035 wxGBPosition result;
42036 PyObject * obj0 = 0 ;
42037 char *kwnames[] = {
42038 (char *) "self", NULL
42039 };
42040
42041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42043 if (SWIG_arg_fail(1)) SWIG_fail;
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 result = ((wxGBSizerItem const *)arg1)->GetPos();
42047
42048 wxPyEndAllowThreads(__tstate);
42049 if (PyErr_Occurred()) SWIG_fail;
42050 }
42051 {
42052 wxGBPosition * resultptr;
42053 resultptr = new wxGBPosition((wxGBPosition &)(result));
42054 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42055 }
42056 return resultobj;
42057 fail:
42058 return NULL;
42059 }
42060
42061
42062 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42063 PyObject *resultobj;
42064 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42065 wxGBSpan result;
42066 PyObject * obj0 = 0 ;
42067 char *kwnames[] = {
42068 (char *) "self", NULL
42069 };
42070
42071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42073 if (SWIG_arg_fail(1)) SWIG_fail;
42074 {
42075 PyThreadState* __tstate = wxPyBeginAllowThreads();
42076 result = ((wxGBSizerItem const *)arg1)->GetSpan();
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_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42093 PyObject *resultobj;
42094 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42095 wxGBPosition *arg2 = 0 ;
42096 bool result;
42097 wxGBPosition temp2 ;
42098 PyObject * obj0 = 0 ;
42099 PyObject * obj1 = 0 ;
42100 char *kwnames[] = {
42101 (char *) "self",(char *) "pos", NULL
42102 };
42103
42104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42106 if (SWIG_arg_fail(1)) SWIG_fail;
42107 {
42108 arg2 = &temp2;
42109 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42110 }
42111 {
42112 PyThreadState* __tstate = wxPyBeginAllowThreads();
42113 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42114
42115 wxPyEndAllowThreads(__tstate);
42116 if (PyErr_Occurred()) SWIG_fail;
42117 }
42118 {
42119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42120 }
42121 return resultobj;
42122 fail:
42123 return NULL;
42124 }
42125
42126
42127 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42128 PyObject *resultobj;
42129 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42130 wxGBSpan *arg2 = 0 ;
42131 bool result;
42132 wxGBSpan temp2 ;
42133 PyObject * obj0 = 0 ;
42134 PyObject * obj1 = 0 ;
42135 char *kwnames[] = {
42136 (char *) "self",(char *) "span", NULL
42137 };
42138
42139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42141 if (SWIG_arg_fail(1)) SWIG_fail;
42142 {
42143 arg2 = &temp2;
42144 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42145 }
42146 {
42147 PyThreadState* __tstate = wxPyBeginAllowThreads();
42148 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42149
42150 wxPyEndAllowThreads(__tstate);
42151 if (PyErr_Occurred()) SWIG_fail;
42152 }
42153 {
42154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42155 }
42156 return resultobj;
42157 fail:
42158 return NULL;
42159 }
42160
42161
42162 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42163 PyObject *resultobj;
42164 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42165 wxGBSizerItem *arg2 = 0 ;
42166 bool result;
42167 PyObject * obj0 = 0 ;
42168 PyObject * obj1 = 0 ;
42169 char *kwnames[] = {
42170 (char *) "self",(char *) "other", NULL
42171 };
42172
42173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42175 if (SWIG_arg_fail(1)) SWIG_fail;
42176 {
42177 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42178 if (SWIG_arg_fail(2)) SWIG_fail;
42179 if (arg2 == NULL) {
42180 SWIG_null_ref("wxGBSizerItem");
42181 }
42182 if (SWIG_arg_fail(2)) SWIG_fail;
42183 }
42184 {
42185 PyThreadState* __tstate = wxPyBeginAllowThreads();
42186 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42187
42188 wxPyEndAllowThreads(__tstate);
42189 if (PyErr_Occurred()) SWIG_fail;
42190 }
42191 {
42192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42193 }
42194 return resultobj;
42195 fail:
42196 return NULL;
42197 }
42198
42199
42200 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42201 PyObject *resultobj;
42202 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42203 wxGBPosition *arg2 = 0 ;
42204 wxGBSpan *arg3 = 0 ;
42205 bool result;
42206 wxGBPosition temp2 ;
42207 wxGBSpan temp3 ;
42208 PyObject * obj0 = 0 ;
42209 PyObject * obj1 = 0 ;
42210 PyObject * obj2 = 0 ;
42211 char *kwnames[] = {
42212 (char *) "self",(char *) "pos",(char *) "span", NULL
42213 };
42214
42215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42217 if (SWIG_arg_fail(1)) SWIG_fail;
42218 {
42219 arg2 = &temp2;
42220 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42221 }
42222 {
42223 arg3 = &temp3;
42224 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42225 }
42226 {
42227 PyThreadState* __tstate = wxPyBeginAllowThreads();
42228 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42229
42230 wxPyEndAllowThreads(__tstate);
42231 if (PyErr_Occurred()) SWIG_fail;
42232 }
42233 {
42234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42235 }
42236 return resultobj;
42237 fail:
42238 return NULL;
42239 }
42240
42241
42242 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42243 PyObject *resultobj;
42244 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42245 wxGBPosition result;
42246 PyObject * obj0 = 0 ;
42247 char *kwnames[] = {
42248 (char *) "self", NULL
42249 };
42250
42251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42253 if (SWIG_arg_fail(1)) SWIG_fail;
42254 {
42255 PyThreadState* __tstate = wxPyBeginAllowThreads();
42256 result = wxGBSizerItem_GetEndPos(arg1);
42257
42258 wxPyEndAllowThreads(__tstate);
42259 if (PyErr_Occurred()) SWIG_fail;
42260 }
42261 {
42262 wxGBPosition * resultptr;
42263 resultptr = new wxGBPosition((wxGBPosition &)(result));
42264 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42265 }
42266 return resultobj;
42267 fail:
42268 return NULL;
42269 }
42270
42271
42272 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42273 PyObject *resultobj;
42274 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42275 wxGridBagSizer *result;
42276 PyObject * obj0 = 0 ;
42277 char *kwnames[] = {
42278 (char *) "self", NULL
42279 };
42280
42281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42283 if (SWIG_arg_fail(1)) SWIG_fail;
42284 {
42285 PyThreadState* __tstate = wxPyBeginAllowThreads();
42286 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42287
42288 wxPyEndAllowThreads(__tstate);
42289 if (PyErr_Occurred()) SWIG_fail;
42290 }
42291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42292 return resultobj;
42293 fail:
42294 return NULL;
42295 }
42296
42297
42298 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42299 PyObject *resultobj;
42300 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42301 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42302 PyObject * obj0 = 0 ;
42303 PyObject * obj1 = 0 ;
42304 char *kwnames[] = {
42305 (char *) "self",(char *) "sizer", NULL
42306 };
42307
42308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42310 if (SWIG_arg_fail(1)) SWIG_fail;
42311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42312 if (SWIG_arg_fail(2)) SWIG_fail;
42313 {
42314 PyThreadState* __tstate = wxPyBeginAllowThreads();
42315 (arg1)->SetGBSizer(arg2);
42316
42317 wxPyEndAllowThreads(__tstate);
42318 if (PyErr_Occurred()) SWIG_fail;
42319 }
42320 Py_INCREF(Py_None); resultobj = Py_None;
42321 return resultobj;
42322 fail:
42323 return NULL;
42324 }
42325
42326
42327 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42328 PyObject *obj;
42329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42330 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42331 Py_INCREF(obj);
42332 return Py_BuildValue((char *)"");
42333 }
42334 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42335 PyObject *resultobj;
42336 int arg1 = (int) 0 ;
42337 int arg2 = (int) 0 ;
42338 wxGridBagSizer *result;
42339 PyObject * obj0 = 0 ;
42340 PyObject * obj1 = 0 ;
42341 char *kwnames[] = {
42342 (char *) "vgap",(char *) "hgap", NULL
42343 };
42344
42345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42346 if (obj0) {
42347 {
42348 arg1 = (int)(SWIG_As_int(obj0));
42349 if (SWIG_arg_fail(1)) SWIG_fail;
42350 }
42351 }
42352 if (obj1) {
42353 {
42354 arg2 = (int)(SWIG_As_int(obj1));
42355 if (SWIG_arg_fail(2)) SWIG_fail;
42356 }
42357 }
42358 {
42359 PyThreadState* __tstate = wxPyBeginAllowThreads();
42360 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42361
42362 wxPyEndAllowThreads(__tstate);
42363 if (PyErr_Occurred()) SWIG_fail;
42364 }
42365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42366 return resultobj;
42367 fail:
42368 return NULL;
42369 }
42370
42371
42372 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42373 PyObject *resultobj;
42374 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42375 PyObject *arg2 = (PyObject *) 0 ;
42376 wxGBPosition *arg3 = 0 ;
42377 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42378 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42379 int arg5 = (int) 0 ;
42380 int arg6 = (int) 0 ;
42381 PyObject *arg7 = (PyObject *) NULL ;
42382 wxGBSizerItem *result;
42383 wxGBPosition temp3 ;
42384 wxGBSpan temp4 ;
42385 PyObject * obj0 = 0 ;
42386 PyObject * obj1 = 0 ;
42387 PyObject * obj2 = 0 ;
42388 PyObject * obj3 = 0 ;
42389 PyObject * obj4 = 0 ;
42390 PyObject * obj5 = 0 ;
42391 PyObject * obj6 = 0 ;
42392 char *kwnames[] = {
42393 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42394 };
42395
42396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42398 if (SWIG_arg_fail(1)) SWIG_fail;
42399 arg2 = obj1;
42400 {
42401 arg3 = &temp3;
42402 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42403 }
42404 if (obj3) {
42405 {
42406 arg4 = &temp4;
42407 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42408 }
42409 }
42410 if (obj4) {
42411 {
42412 arg5 = (int)(SWIG_As_int(obj4));
42413 if (SWIG_arg_fail(5)) SWIG_fail;
42414 }
42415 }
42416 if (obj5) {
42417 {
42418 arg6 = (int)(SWIG_As_int(obj5));
42419 if (SWIG_arg_fail(6)) SWIG_fail;
42420 }
42421 }
42422 if (obj6) {
42423 arg7 = obj6;
42424 }
42425 {
42426 PyThreadState* __tstate = wxPyBeginAllowThreads();
42427 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42428
42429 wxPyEndAllowThreads(__tstate);
42430 if (PyErr_Occurred()) SWIG_fail;
42431 }
42432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42433 return resultobj;
42434 fail:
42435 return NULL;
42436 }
42437
42438
42439 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42440 PyObject *resultobj;
42441 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42442 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42443 wxGBSizerItem *result;
42444 PyObject * obj0 = 0 ;
42445 PyObject * obj1 = 0 ;
42446 char *kwnames[] = {
42447 (char *) "self",(char *) "item", NULL
42448 };
42449
42450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42452 if (SWIG_arg_fail(1)) SWIG_fail;
42453 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42454 if (SWIG_arg_fail(2)) SWIG_fail;
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42458
42459 wxPyEndAllowThreads(__tstate);
42460 if (PyErr_Occurred()) SWIG_fail;
42461 }
42462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42463 return resultobj;
42464 fail:
42465 return NULL;
42466 }
42467
42468
42469 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42470 PyObject *resultobj;
42471 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42472 int arg2 ;
42473 int arg3 ;
42474 wxSize result;
42475 PyObject * obj0 = 0 ;
42476 PyObject * obj1 = 0 ;
42477 PyObject * obj2 = 0 ;
42478 char *kwnames[] = {
42479 (char *) "self",(char *) "row",(char *) "col", NULL
42480 };
42481
42482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42484 if (SWIG_arg_fail(1)) SWIG_fail;
42485 {
42486 arg2 = (int)(SWIG_As_int(obj1));
42487 if (SWIG_arg_fail(2)) SWIG_fail;
42488 }
42489 {
42490 arg3 = (int)(SWIG_As_int(obj2));
42491 if (SWIG_arg_fail(3)) SWIG_fail;
42492 }
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42496
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 {
42501 wxSize * resultptr;
42502 resultptr = new wxSize((wxSize &)(result));
42503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42504 }
42505 return resultobj;
42506 fail:
42507 return NULL;
42508 }
42509
42510
42511 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42512 PyObject *resultobj;
42513 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42514 wxSize result;
42515 PyObject * obj0 = 0 ;
42516 char *kwnames[] = {
42517 (char *) "self", NULL
42518 };
42519
42520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42522 if (SWIG_arg_fail(1)) SWIG_fail;
42523 {
42524 PyThreadState* __tstate = wxPyBeginAllowThreads();
42525 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42526
42527 wxPyEndAllowThreads(__tstate);
42528 if (PyErr_Occurred()) SWIG_fail;
42529 }
42530 {
42531 wxSize * resultptr;
42532 resultptr = new wxSize((wxSize &)(result));
42533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42534 }
42535 return resultobj;
42536 fail:
42537 return NULL;
42538 }
42539
42540
42541 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42542 PyObject *resultobj;
42543 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42544 wxSize *arg2 = 0 ;
42545 wxSize temp2 ;
42546 PyObject * obj0 = 0 ;
42547 PyObject * obj1 = 0 ;
42548 char *kwnames[] = {
42549 (char *) "self",(char *) "sz", NULL
42550 };
42551
42552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42554 if (SWIG_arg_fail(1)) SWIG_fail;
42555 {
42556 arg2 = &temp2;
42557 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42558 }
42559 {
42560 PyThreadState* __tstate = wxPyBeginAllowThreads();
42561 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42562
42563 wxPyEndAllowThreads(__tstate);
42564 if (PyErr_Occurred()) SWIG_fail;
42565 }
42566 Py_INCREF(Py_None); resultobj = Py_None;
42567 return resultobj;
42568 fail:
42569 return NULL;
42570 }
42571
42572
42573 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42574 PyObject *resultobj;
42575 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42576 wxWindow *arg2 = (wxWindow *) 0 ;
42577 wxGBPosition result;
42578 PyObject * obj0 = 0 ;
42579 PyObject * obj1 = 0 ;
42580
42581 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42583 if (SWIG_arg_fail(1)) SWIG_fail;
42584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42585 if (SWIG_arg_fail(2)) SWIG_fail;
42586 {
42587 PyThreadState* __tstate = wxPyBeginAllowThreads();
42588 result = (arg1)->GetItemPosition(arg2);
42589
42590 wxPyEndAllowThreads(__tstate);
42591 if (PyErr_Occurred()) SWIG_fail;
42592 }
42593 {
42594 wxGBPosition * resultptr;
42595 resultptr = new wxGBPosition((wxGBPosition &)(result));
42596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42597 }
42598 return resultobj;
42599 fail:
42600 return NULL;
42601 }
42602
42603
42604 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42605 PyObject *resultobj;
42606 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42607 wxSizer *arg2 = (wxSizer *) 0 ;
42608 wxGBPosition result;
42609 PyObject * obj0 = 0 ;
42610 PyObject * obj1 = 0 ;
42611
42612 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42614 if (SWIG_arg_fail(1)) SWIG_fail;
42615 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42616 if (SWIG_arg_fail(2)) SWIG_fail;
42617 {
42618 PyThreadState* __tstate = wxPyBeginAllowThreads();
42619 result = (arg1)->GetItemPosition(arg2);
42620
42621 wxPyEndAllowThreads(__tstate);
42622 if (PyErr_Occurred()) SWIG_fail;
42623 }
42624 {
42625 wxGBPosition * resultptr;
42626 resultptr = new wxGBPosition((wxGBPosition &)(result));
42627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42628 }
42629 return resultobj;
42630 fail:
42631 return NULL;
42632 }
42633
42634
42635 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42636 PyObject *resultobj;
42637 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42638 size_t arg2 ;
42639 wxGBPosition result;
42640 PyObject * obj0 = 0 ;
42641 PyObject * obj1 = 0 ;
42642
42643 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42645 if (SWIG_arg_fail(1)) SWIG_fail;
42646 {
42647 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42648 if (SWIG_arg_fail(2)) SWIG_fail;
42649 }
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 result = (arg1)->GetItemPosition(arg2);
42653
42654 wxPyEndAllowThreads(__tstate);
42655 if (PyErr_Occurred()) SWIG_fail;
42656 }
42657 {
42658 wxGBPosition * resultptr;
42659 resultptr = new wxGBPosition((wxGBPosition &)(result));
42660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42661 }
42662 return resultobj;
42663 fail:
42664 return NULL;
42665 }
42666
42667
42668 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42669 int argc;
42670 PyObject *argv[3];
42671 int ii;
42672
42673 argc = PyObject_Length(args);
42674 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42675 argv[ii] = PyTuple_GetItem(args,ii);
42676 }
42677 if (argc == 2) {
42678 int _v;
42679 {
42680 void *ptr;
42681 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42682 _v = 0;
42683 PyErr_Clear();
42684 } else {
42685 _v = 1;
42686 }
42687 }
42688 if (_v) {
42689 {
42690 void *ptr;
42691 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42692 _v = 0;
42693 PyErr_Clear();
42694 } else {
42695 _v = 1;
42696 }
42697 }
42698 if (_v) {
42699 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42700 }
42701 }
42702 }
42703 if (argc == 2) {
42704 int _v;
42705 {
42706 void *ptr;
42707 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42708 _v = 0;
42709 PyErr_Clear();
42710 } else {
42711 _v = 1;
42712 }
42713 }
42714 if (_v) {
42715 {
42716 void *ptr;
42717 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42718 _v = 0;
42719 PyErr_Clear();
42720 } else {
42721 _v = 1;
42722 }
42723 }
42724 if (_v) {
42725 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42726 }
42727 }
42728 }
42729 if (argc == 2) {
42730 int _v;
42731 {
42732 void *ptr;
42733 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42734 _v = 0;
42735 PyErr_Clear();
42736 } else {
42737 _v = 1;
42738 }
42739 }
42740 if (_v) {
42741 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42742 if (_v) {
42743 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42744 }
42745 }
42746 }
42747
42748 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42749 return NULL;
42750 }
42751
42752
42753 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42754 PyObject *resultobj;
42755 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42756 wxWindow *arg2 = (wxWindow *) 0 ;
42757 wxGBPosition *arg3 = 0 ;
42758 bool result;
42759 wxGBPosition temp3 ;
42760 PyObject * obj0 = 0 ;
42761 PyObject * obj1 = 0 ;
42762 PyObject * obj2 = 0 ;
42763
42764 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42766 if (SWIG_arg_fail(1)) SWIG_fail;
42767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42768 if (SWIG_arg_fail(2)) SWIG_fail;
42769 {
42770 arg3 = &temp3;
42771 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42772 }
42773 {
42774 PyThreadState* __tstate = wxPyBeginAllowThreads();
42775 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42776
42777 wxPyEndAllowThreads(__tstate);
42778 if (PyErr_Occurred()) SWIG_fail;
42779 }
42780 {
42781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42782 }
42783 return resultobj;
42784 fail:
42785 return NULL;
42786 }
42787
42788
42789 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42790 PyObject *resultobj;
42791 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42792 wxSizer *arg2 = (wxSizer *) 0 ;
42793 wxGBPosition *arg3 = 0 ;
42794 bool result;
42795 wxGBPosition temp3 ;
42796 PyObject * obj0 = 0 ;
42797 PyObject * obj1 = 0 ;
42798 PyObject * obj2 = 0 ;
42799
42800 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42802 if (SWIG_arg_fail(1)) SWIG_fail;
42803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42804 if (SWIG_arg_fail(2)) SWIG_fail;
42805 {
42806 arg3 = &temp3;
42807 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42808 }
42809 {
42810 PyThreadState* __tstate = wxPyBeginAllowThreads();
42811 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42812
42813 wxPyEndAllowThreads(__tstate);
42814 if (PyErr_Occurred()) SWIG_fail;
42815 }
42816 {
42817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42818 }
42819 return resultobj;
42820 fail:
42821 return NULL;
42822 }
42823
42824
42825 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42826 PyObject *resultobj;
42827 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42828 size_t arg2 ;
42829 wxGBPosition *arg3 = 0 ;
42830 bool result;
42831 wxGBPosition temp3 ;
42832 PyObject * obj0 = 0 ;
42833 PyObject * obj1 = 0 ;
42834 PyObject * obj2 = 0 ;
42835
42836 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42838 if (SWIG_arg_fail(1)) SWIG_fail;
42839 {
42840 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42841 if (SWIG_arg_fail(2)) SWIG_fail;
42842 }
42843 {
42844 arg3 = &temp3;
42845 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42846 }
42847 {
42848 PyThreadState* __tstate = wxPyBeginAllowThreads();
42849 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42850
42851 wxPyEndAllowThreads(__tstate);
42852 if (PyErr_Occurred()) SWIG_fail;
42853 }
42854 {
42855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42856 }
42857 return resultobj;
42858 fail:
42859 return NULL;
42860 }
42861
42862
42863 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42864 int argc;
42865 PyObject *argv[4];
42866 int ii;
42867
42868 argc = PyObject_Length(args);
42869 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42870 argv[ii] = PyTuple_GetItem(args,ii);
42871 }
42872 if (argc == 3) {
42873 int _v;
42874 {
42875 void *ptr;
42876 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42877 _v = 0;
42878 PyErr_Clear();
42879 } else {
42880 _v = 1;
42881 }
42882 }
42883 if (_v) {
42884 {
42885 void *ptr;
42886 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42887 _v = 0;
42888 PyErr_Clear();
42889 } else {
42890 _v = 1;
42891 }
42892 }
42893 if (_v) {
42894 {
42895 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42896 }
42897 if (_v) {
42898 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42899 }
42900 }
42901 }
42902 }
42903 if (argc == 3) {
42904 int _v;
42905 {
42906 void *ptr;
42907 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42908 _v = 0;
42909 PyErr_Clear();
42910 } else {
42911 _v = 1;
42912 }
42913 }
42914 if (_v) {
42915 {
42916 void *ptr;
42917 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42918 _v = 0;
42919 PyErr_Clear();
42920 } else {
42921 _v = 1;
42922 }
42923 }
42924 if (_v) {
42925 {
42926 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42927 }
42928 if (_v) {
42929 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42930 }
42931 }
42932 }
42933 }
42934 if (argc == 3) {
42935 int _v;
42936 {
42937 void *ptr;
42938 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42939 _v = 0;
42940 PyErr_Clear();
42941 } else {
42942 _v = 1;
42943 }
42944 }
42945 if (_v) {
42946 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42947 if (_v) {
42948 {
42949 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42950 }
42951 if (_v) {
42952 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42953 }
42954 }
42955 }
42956 }
42957
42958 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42959 return NULL;
42960 }
42961
42962
42963 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42964 PyObject *resultobj;
42965 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42966 wxWindow *arg2 = (wxWindow *) 0 ;
42967 wxGBSpan result;
42968 PyObject * obj0 = 0 ;
42969 PyObject * obj1 = 0 ;
42970
42971 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42973 if (SWIG_arg_fail(1)) SWIG_fail;
42974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42975 if (SWIG_arg_fail(2)) SWIG_fail;
42976 {
42977 PyThreadState* __tstate = wxPyBeginAllowThreads();
42978 result = (arg1)->GetItemSpan(arg2);
42979
42980 wxPyEndAllowThreads(__tstate);
42981 if (PyErr_Occurred()) SWIG_fail;
42982 }
42983 {
42984 wxGBSpan * resultptr;
42985 resultptr = new wxGBSpan((wxGBSpan &)(result));
42986 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42987 }
42988 return resultobj;
42989 fail:
42990 return NULL;
42991 }
42992
42993
42994 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42995 PyObject *resultobj;
42996 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42997 wxSizer *arg2 = (wxSizer *) 0 ;
42998 wxGBSpan result;
42999 PyObject * obj0 = 0 ;
43000 PyObject * obj1 = 0 ;
43001
43002 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43004 if (SWIG_arg_fail(1)) SWIG_fail;
43005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43006 if (SWIG_arg_fail(2)) SWIG_fail;
43007 {
43008 PyThreadState* __tstate = wxPyBeginAllowThreads();
43009 result = (arg1)->GetItemSpan(arg2);
43010
43011 wxPyEndAllowThreads(__tstate);
43012 if (PyErr_Occurred()) SWIG_fail;
43013 }
43014 {
43015 wxGBSpan * resultptr;
43016 resultptr = new wxGBSpan((wxGBSpan &)(result));
43017 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43018 }
43019 return resultobj;
43020 fail:
43021 return NULL;
43022 }
43023
43024
43025 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43026 PyObject *resultobj;
43027 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43028 size_t arg2 ;
43029 wxGBSpan result;
43030 PyObject * obj0 = 0 ;
43031 PyObject * obj1 = 0 ;
43032
43033 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43035 if (SWIG_arg_fail(1)) SWIG_fail;
43036 {
43037 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43038 if (SWIG_arg_fail(2)) SWIG_fail;
43039 }
43040 {
43041 PyThreadState* __tstate = wxPyBeginAllowThreads();
43042 result = (arg1)->GetItemSpan(arg2);
43043
43044 wxPyEndAllowThreads(__tstate);
43045 if (PyErr_Occurred()) SWIG_fail;
43046 }
43047 {
43048 wxGBSpan * resultptr;
43049 resultptr = new wxGBSpan((wxGBSpan &)(result));
43050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43051 }
43052 return resultobj;
43053 fail:
43054 return NULL;
43055 }
43056
43057
43058 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43059 int argc;
43060 PyObject *argv[3];
43061 int ii;
43062
43063 argc = PyObject_Length(args);
43064 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43065 argv[ii] = PyTuple_GetItem(args,ii);
43066 }
43067 if (argc == 2) {
43068 int _v;
43069 {
43070 void *ptr;
43071 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43072 _v = 0;
43073 PyErr_Clear();
43074 } else {
43075 _v = 1;
43076 }
43077 }
43078 if (_v) {
43079 {
43080 void *ptr;
43081 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43082 _v = 0;
43083 PyErr_Clear();
43084 } else {
43085 _v = 1;
43086 }
43087 }
43088 if (_v) {
43089 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43090 }
43091 }
43092 }
43093 if (argc == 2) {
43094 int _v;
43095 {
43096 void *ptr;
43097 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43098 _v = 0;
43099 PyErr_Clear();
43100 } else {
43101 _v = 1;
43102 }
43103 }
43104 if (_v) {
43105 {
43106 void *ptr;
43107 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43108 _v = 0;
43109 PyErr_Clear();
43110 } else {
43111 _v = 1;
43112 }
43113 }
43114 if (_v) {
43115 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43116 }
43117 }
43118 }
43119 if (argc == 2) {
43120 int _v;
43121 {
43122 void *ptr;
43123 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43124 _v = 0;
43125 PyErr_Clear();
43126 } else {
43127 _v = 1;
43128 }
43129 }
43130 if (_v) {
43131 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43132 if (_v) {
43133 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43134 }
43135 }
43136 }
43137
43138 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43139 return NULL;
43140 }
43141
43142
43143 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43144 PyObject *resultobj;
43145 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43146 wxWindow *arg2 = (wxWindow *) 0 ;
43147 wxGBSpan *arg3 = 0 ;
43148 bool result;
43149 wxGBSpan temp3 ;
43150 PyObject * obj0 = 0 ;
43151 PyObject * obj1 = 0 ;
43152 PyObject * obj2 = 0 ;
43153
43154 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43156 if (SWIG_arg_fail(1)) SWIG_fail;
43157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43158 if (SWIG_arg_fail(2)) SWIG_fail;
43159 {
43160 arg3 = &temp3;
43161 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43162 }
43163 {
43164 PyThreadState* __tstate = wxPyBeginAllowThreads();
43165 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43166
43167 wxPyEndAllowThreads(__tstate);
43168 if (PyErr_Occurred()) SWIG_fail;
43169 }
43170 {
43171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43172 }
43173 return resultobj;
43174 fail:
43175 return NULL;
43176 }
43177
43178
43179 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43180 PyObject *resultobj;
43181 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43182 wxSizer *arg2 = (wxSizer *) 0 ;
43183 wxGBSpan *arg3 = 0 ;
43184 bool result;
43185 wxGBSpan temp3 ;
43186 PyObject * obj0 = 0 ;
43187 PyObject * obj1 = 0 ;
43188 PyObject * obj2 = 0 ;
43189
43190 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43192 if (SWIG_arg_fail(1)) SWIG_fail;
43193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43194 if (SWIG_arg_fail(2)) SWIG_fail;
43195 {
43196 arg3 = &temp3;
43197 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43198 }
43199 {
43200 PyThreadState* __tstate = wxPyBeginAllowThreads();
43201 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43202
43203 wxPyEndAllowThreads(__tstate);
43204 if (PyErr_Occurred()) SWIG_fail;
43205 }
43206 {
43207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43208 }
43209 return resultobj;
43210 fail:
43211 return NULL;
43212 }
43213
43214
43215 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43216 PyObject *resultobj;
43217 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43218 size_t arg2 ;
43219 wxGBSpan *arg3 = 0 ;
43220 bool result;
43221 wxGBSpan temp3 ;
43222 PyObject * obj0 = 0 ;
43223 PyObject * obj1 = 0 ;
43224 PyObject * obj2 = 0 ;
43225
43226 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43228 if (SWIG_arg_fail(1)) SWIG_fail;
43229 {
43230 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43231 if (SWIG_arg_fail(2)) SWIG_fail;
43232 }
43233 {
43234 arg3 = &temp3;
43235 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43236 }
43237 {
43238 PyThreadState* __tstate = wxPyBeginAllowThreads();
43239 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43240
43241 wxPyEndAllowThreads(__tstate);
43242 if (PyErr_Occurred()) SWIG_fail;
43243 }
43244 {
43245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43246 }
43247 return resultobj;
43248 fail:
43249 return NULL;
43250 }
43251
43252
43253 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43254 int argc;
43255 PyObject *argv[4];
43256 int ii;
43257
43258 argc = PyObject_Length(args);
43259 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43260 argv[ii] = PyTuple_GetItem(args,ii);
43261 }
43262 if (argc == 3) {
43263 int _v;
43264 {
43265 void *ptr;
43266 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43267 _v = 0;
43268 PyErr_Clear();
43269 } else {
43270 _v = 1;
43271 }
43272 }
43273 if (_v) {
43274 {
43275 void *ptr;
43276 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43277 _v = 0;
43278 PyErr_Clear();
43279 } else {
43280 _v = 1;
43281 }
43282 }
43283 if (_v) {
43284 {
43285 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43286 }
43287 if (_v) {
43288 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43289 }
43290 }
43291 }
43292 }
43293 if (argc == 3) {
43294 int _v;
43295 {
43296 void *ptr;
43297 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43298 _v = 0;
43299 PyErr_Clear();
43300 } else {
43301 _v = 1;
43302 }
43303 }
43304 if (_v) {
43305 {
43306 void *ptr;
43307 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43308 _v = 0;
43309 PyErr_Clear();
43310 } else {
43311 _v = 1;
43312 }
43313 }
43314 if (_v) {
43315 {
43316 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43317 }
43318 if (_v) {
43319 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43320 }
43321 }
43322 }
43323 }
43324 if (argc == 3) {
43325 int _v;
43326 {
43327 void *ptr;
43328 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43329 _v = 0;
43330 PyErr_Clear();
43331 } else {
43332 _v = 1;
43333 }
43334 }
43335 if (_v) {
43336 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43337 if (_v) {
43338 {
43339 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43340 }
43341 if (_v) {
43342 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43343 }
43344 }
43345 }
43346 }
43347
43348 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43349 return NULL;
43350 }
43351
43352
43353 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43354 PyObject *resultobj;
43355 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43356 wxWindow *arg2 = (wxWindow *) 0 ;
43357 wxGBSizerItem *result;
43358 PyObject * obj0 = 0 ;
43359 PyObject * obj1 = 0 ;
43360
43361 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43363 if (SWIG_arg_fail(1)) SWIG_fail;
43364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43365 if (SWIG_arg_fail(2)) SWIG_fail;
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43369
43370 wxPyEndAllowThreads(__tstate);
43371 if (PyErr_Occurred()) SWIG_fail;
43372 }
43373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43374 return resultobj;
43375 fail:
43376 return NULL;
43377 }
43378
43379
43380 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43381 PyObject *resultobj;
43382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43383 wxSizer *arg2 = (wxSizer *) 0 ;
43384 wxGBSizerItem *result;
43385 PyObject * obj0 = 0 ;
43386 PyObject * obj1 = 0 ;
43387
43388 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43390 if (SWIG_arg_fail(1)) SWIG_fail;
43391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43392 if (SWIG_arg_fail(2)) SWIG_fail;
43393 {
43394 PyThreadState* __tstate = wxPyBeginAllowThreads();
43395 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43396
43397 wxPyEndAllowThreads(__tstate);
43398 if (PyErr_Occurred()) SWIG_fail;
43399 }
43400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43401 return resultobj;
43402 fail:
43403 return NULL;
43404 }
43405
43406
43407 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43408 int argc;
43409 PyObject *argv[3];
43410 int ii;
43411
43412 argc = PyObject_Length(args);
43413 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43414 argv[ii] = PyTuple_GetItem(args,ii);
43415 }
43416 if (argc == 2) {
43417 int _v;
43418 {
43419 void *ptr;
43420 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43421 _v = 0;
43422 PyErr_Clear();
43423 } else {
43424 _v = 1;
43425 }
43426 }
43427 if (_v) {
43428 {
43429 void *ptr;
43430 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43431 _v = 0;
43432 PyErr_Clear();
43433 } else {
43434 _v = 1;
43435 }
43436 }
43437 if (_v) {
43438 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43439 }
43440 }
43441 }
43442 if (argc == 2) {
43443 int _v;
43444 {
43445 void *ptr;
43446 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43447 _v = 0;
43448 PyErr_Clear();
43449 } else {
43450 _v = 1;
43451 }
43452 }
43453 if (_v) {
43454 {
43455 void *ptr;
43456 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43457 _v = 0;
43458 PyErr_Clear();
43459 } else {
43460 _v = 1;
43461 }
43462 }
43463 if (_v) {
43464 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43465 }
43466 }
43467 }
43468
43469 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43470 return NULL;
43471 }
43472
43473
43474 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43475 PyObject *resultobj;
43476 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43477 wxGBPosition *arg2 = 0 ;
43478 wxGBSizerItem *result;
43479 wxGBPosition temp2 ;
43480 PyObject * obj0 = 0 ;
43481 PyObject * obj1 = 0 ;
43482 char *kwnames[] = {
43483 (char *) "self",(char *) "pos", NULL
43484 };
43485
43486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43488 if (SWIG_arg_fail(1)) SWIG_fail;
43489 {
43490 arg2 = &temp2;
43491 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43492 }
43493 {
43494 PyThreadState* __tstate = wxPyBeginAllowThreads();
43495 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43496
43497 wxPyEndAllowThreads(__tstate);
43498 if (PyErr_Occurred()) SWIG_fail;
43499 }
43500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43501 return resultobj;
43502 fail:
43503 return NULL;
43504 }
43505
43506
43507 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43508 PyObject *resultobj;
43509 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43510 wxPoint *arg2 = 0 ;
43511 wxGBSizerItem *result;
43512 wxPoint temp2 ;
43513 PyObject * obj0 = 0 ;
43514 PyObject * obj1 = 0 ;
43515 char *kwnames[] = {
43516 (char *) "self",(char *) "pt", NULL
43517 };
43518
43519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43521 if (SWIG_arg_fail(1)) SWIG_fail;
43522 {
43523 arg2 = &temp2;
43524 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43525 }
43526 {
43527 PyThreadState* __tstate = wxPyBeginAllowThreads();
43528 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43529
43530 wxPyEndAllowThreads(__tstate);
43531 if (PyErr_Occurred()) SWIG_fail;
43532 }
43533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43534 return resultobj;
43535 fail:
43536 return NULL;
43537 }
43538
43539
43540 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43541 PyObject *resultobj;
43542 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43543 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43544 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43545 bool result;
43546 PyObject * obj0 = 0 ;
43547 PyObject * obj1 = 0 ;
43548 PyObject * obj2 = 0 ;
43549 char *kwnames[] = {
43550 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43551 };
43552
43553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43555 if (SWIG_arg_fail(1)) SWIG_fail;
43556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43557 if (SWIG_arg_fail(2)) SWIG_fail;
43558 if (obj2) {
43559 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43560 if (SWIG_arg_fail(3)) SWIG_fail;
43561 }
43562 {
43563 PyThreadState* __tstate = wxPyBeginAllowThreads();
43564 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43565
43566 wxPyEndAllowThreads(__tstate);
43567 if (PyErr_Occurred()) SWIG_fail;
43568 }
43569 {
43570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43571 }
43572 return resultobj;
43573 fail:
43574 return NULL;
43575 }
43576
43577
43578 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43579 PyObject *resultobj;
43580 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43581 wxGBPosition *arg2 = 0 ;
43582 wxGBSpan *arg3 = 0 ;
43583 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43584 bool result;
43585 wxGBPosition temp2 ;
43586 wxGBSpan temp3 ;
43587 PyObject * obj0 = 0 ;
43588 PyObject * obj1 = 0 ;
43589 PyObject * obj2 = 0 ;
43590 PyObject * obj3 = 0 ;
43591 char *kwnames[] = {
43592 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43593 };
43594
43595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43597 if (SWIG_arg_fail(1)) SWIG_fail;
43598 {
43599 arg2 = &temp2;
43600 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43601 }
43602 {
43603 arg3 = &temp3;
43604 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43605 }
43606 if (obj3) {
43607 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43608 if (SWIG_arg_fail(4)) SWIG_fail;
43609 }
43610 {
43611 PyThreadState* __tstate = wxPyBeginAllowThreads();
43612 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43613
43614 wxPyEndAllowThreads(__tstate);
43615 if (PyErr_Occurred()) SWIG_fail;
43616 }
43617 {
43618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43619 }
43620 return resultobj;
43621 fail:
43622 return NULL;
43623 }
43624
43625
43626 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43627 PyObject *obj;
43628 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43629 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43630 Py_INCREF(obj);
43631 return Py_BuildValue((char *)"");
43632 }
43633 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43634 PyObject *resultobj;
43635 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43636 wxRelationship arg2 ;
43637 wxWindow *arg3 = (wxWindow *) 0 ;
43638 wxEdge arg4 ;
43639 int arg5 = (int) 0 ;
43640 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43641 PyObject * obj0 = 0 ;
43642 PyObject * obj1 = 0 ;
43643 PyObject * obj2 = 0 ;
43644 PyObject * obj3 = 0 ;
43645 PyObject * obj4 = 0 ;
43646 PyObject * obj5 = 0 ;
43647 char *kwnames[] = {
43648 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43649 };
43650
43651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43653 if (SWIG_arg_fail(1)) SWIG_fail;
43654 {
43655 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43656 if (SWIG_arg_fail(2)) SWIG_fail;
43657 }
43658 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43659 if (SWIG_arg_fail(3)) SWIG_fail;
43660 {
43661 arg4 = (wxEdge)(SWIG_As_int(obj3));
43662 if (SWIG_arg_fail(4)) SWIG_fail;
43663 }
43664 if (obj4) {
43665 {
43666 arg5 = (int)(SWIG_As_int(obj4));
43667 if (SWIG_arg_fail(5)) SWIG_fail;
43668 }
43669 }
43670 if (obj5) {
43671 {
43672 arg6 = (int)(SWIG_As_int(obj5));
43673 if (SWIG_arg_fail(6)) SWIG_fail;
43674 }
43675 }
43676 {
43677 PyThreadState* __tstate = wxPyBeginAllowThreads();
43678 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43679
43680 wxPyEndAllowThreads(__tstate);
43681 if (PyErr_Occurred()) SWIG_fail;
43682 }
43683 Py_INCREF(Py_None); resultobj = Py_None;
43684 return resultobj;
43685 fail:
43686 return NULL;
43687 }
43688
43689
43690 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43691 PyObject *resultobj;
43692 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43693 wxWindow *arg2 = (wxWindow *) 0 ;
43694 int arg3 = (int) 0 ;
43695 PyObject * obj0 = 0 ;
43696 PyObject * obj1 = 0 ;
43697 PyObject * obj2 = 0 ;
43698 char *kwnames[] = {
43699 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43700 };
43701
43702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43704 if (SWIG_arg_fail(1)) SWIG_fail;
43705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43706 if (SWIG_arg_fail(2)) SWIG_fail;
43707 if (obj2) {
43708 {
43709 arg3 = (int)(SWIG_As_int(obj2));
43710 if (SWIG_arg_fail(3)) SWIG_fail;
43711 }
43712 }
43713 {
43714 PyThreadState* __tstate = wxPyBeginAllowThreads();
43715 (arg1)->LeftOf(arg2,arg3);
43716
43717 wxPyEndAllowThreads(__tstate);
43718 if (PyErr_Occurred()) SWIG_fail;
43719 }
43720 Py_INCREF(Py_None); resultobj = Py_None;
43721 return resultobj;
43722 fail:
43723 return NULL;
43724 }
43725
43726
43727 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43728 PyObject *resultobj;
43729 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43730 wxWindow *arg2 = (wxWindow *) 0 ;
43731 int arg3 = (int) 0 ;
43732 PyObject * obj0 = 0 ;
43733 PyObject * obj1 = 0 ;
43734 PyObject * obj2 = 0 ;
43735 char *kwnames[] = {
43736 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43737 };
43738
43739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43741 if (SWIG_arg_fail(1)) SWIG_fail;
43742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43743 if (SWIG_arg_fail(2)) SWIG_fail;
43744 if (obj2) {
43745 {
43746 arg3 = (int)(SWIG_As_int(obj2));
43747 if (SWIG_arg_fail(3)) SWIG_fail;
43748 }
43749 }
43750 {
43751 PyThreadState* __tstate = wxPyBeginAllowThreads();
43752 (arg1)->RightOf(arg2,arg3);
43753
43754 wxPyEndAllowThreads(__tstate);
43755 if (PyErr_Occurred()) SWIG_fail;
43756 }
43757 Py_INCREF(Py_None); resultobj = Py_None;
43758 return resultobj;
43759 fail:
43760 return NULL;
43761 }
43762
43763
43764 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43765 PyObject *resultobj;
43766 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43767 wxWindow *arg2 = (wxWindow *) 0 ;
43768 int arg3 = (int) 0 ;
43769 PyObject * obj0 = 0 ;
43770 PyObject * obj1 = 0 ;
43771 PyObject * obj2 = 0 ;
43772 char *kwnames[] = {
43773 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43774 };
43775
43776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43778 if (SWIG_arg_fail(1)) SWIG_fail;
43779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43780 if (SWIG_arg_fail(2)) SWIG_fail;
43781 if (obj2) {
43782 {
43783 arg3 = (int)(SWIG_As_int(obj2));
43784 if (SWIG_arg_fail(3)) SWIG_fail;
43785 }
43786 }
43787 {
43788 PyThreadState* __tstate = wxPyBeginAllowThreads();
43789 (arg1)->Above(arg2,arg3);
43790
43791 wxPyEndAllowThreads(__tstate);
43792 if (PyErr_Occurred()) SWIG_fail;
43793 }
43794 Py_INCREF(Py_None); resultobj = Py_None;
43795 return resultobj;
43796 fail:
43797 return NULL;
43798 }
43799
43800
43801 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43802 PyObject *resultobj;
43803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43804 wxWindow *arg2 = (wxWindow *) 0 ;
43805 int arg3 = (int) 0 ;
43806 PyObject * obj0 = 0 ;
43807 PyObject * obj1 = 0 ;
43808 PyObject * obj2 = 0 ;
43809 char *kwnames[] = {
43810 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43811 };
43812
43813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43815 if (SWIG_arg_fail(1)) SWIG_fail;
43816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43817 if (SWIG_arg_fail(2)) SWIG_fail;
43818 if (obj2) {
43819 {
43820 arg3 = (int)(SWIG_As_int(obj2));
43821 if (SWIG_arg_fail(3)) SWIG_fail;
43822 }
43823 }
43824 {
43825 PyThreadState* __tstate = wxPyBeginAllowThreads();
43826 (arg1)->Below(arg2,arg3);
43827
43828 wxPyEndAllowThreads(__tstate);
43829 if (PyErr_Occurred()) SWIG_fail;
43830 }
43831 Py_INCREF(Py_None); resultobj = Py_None;
43832 return resultobj;
43833 fail:
43834 return NULL;
43835 }
43836
43837
43838 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43839 PyObject *resultobj;
43840 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43841 wxWindow *arg2 = (wxWindow *) 0 ;
43842 wxEdge arg3 ;
43843 int arg4 = (int) 0 ;
43844 PyObject * obj0 = 0 ;
43845 PyObject * obj1 = 0 ;
43846 PyObject * obj2 = 0 ;
43847 PyObject * obj3 = 0 ;
43848 char *kwnames[] = {
43849 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43850 };
43851
43852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43854 if (SWIG_arg_fail(1)) SWIG_fail;
43855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43856 if (SWIG_arg_fail(2)) SWIG_fail;
43857 {
43858 arg3 = (wxEdge)(SWIG_As_int(obj2));
43859 if (SWIG_arg_fail(3)) SWIG_fail;
43860 }
43861 if (obj3) {
43862 {
43863 arg4 = (int)(SWIG_As_int(obj3));
43864 if (SWIG_arg_fail(4)) SWIG_fail;
43865 }
43866 }
43867 {
43868 PyThreadState* __tstate = wxPyBeginAllowThreads();
43869 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43870
43871 wxPyEndAllowThreads(__tstate);
43872 if (PyErr_Occurred()) SWIG_fail;
43873 }
43874 Py_INCREF(Py_None); resultobj = Py_None;
43875 return resultobj;
43876 fail:
43877 return NULL;
43878 }
43879
43880
43881 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43882 PyObject *resultobj;
43883 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43884 wxWindow *arg2 = (wxWindow *) 0 ;
43885 wxEdge arg3 ;
43886 int arg4 ;
43887 PyObject * obj0 = 0 ;
43888 PyObject * obj1 = 0 ;
43889 PyObject * obj2 = 0 ;
43890 PyObject * obj3 = 0 ;
43891 char *kwnames[] = {
43892 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43893 };
43894
43895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43897 if (SWIG_arg_fail(1)) SWIG_fail;
43898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43899 if (SWIG_arg_fail(2)) SWIG_fail;
43900 {
43901 arg3 = (wxEdge)(SWIG_As_int(obj2));
43902 if (SWIG_arg_fail(3)) SWIG_fail;
43903 }
43904 {
43905 arg4 = (int)(SWIG_As_int(obj3));
43906 if (SWIG_arg_fail(4)) SWIG_fail;
43907 }
43908 {
43909 PyThreadState* __tstate = wxPyBeginAllowThreads();
43910 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43911
43912 wxPyEndAllowThreads(__tstate);
43913 if (PyErr_Occurred()) SWIG_fail;
43914 }
43915 Py_INCREF(Py_None); resultobj = Py_None;
43916 return resultobj;
43917 fail:
43918 return NULL;
43919 }
43920
43921
43922 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43923 PyObject *resultobj;
43924 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43925 int arg2 ;
43926 PyObject * obj0 = 0 ;
43927 PyObject * obj1 = 0 ;
43928 char *kwnames[] = {
43929 (char *) "self",(char *) "val", NULL
43930 };
43931
43932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43934 if (SWIG_arg_fail(1)) SWIG_fail;
43935 {
43936 arg2 = (int)(SWIG_As_int(obj1));
43937 if (SWIG_arg_fail(2)) SWIG_fail;
43938 }
43939 {
43940 PyThreadState* __tstate = wxPyBeginAllowThreads();
43941 (arg1)->Absolute(arg2);
43942
43943 wxPyEndAllowThreads(__tstate);
43944 if (PyErr_Occurred()) SWIG_fail;
43945 }
43946 Py_INCREF(Py_None); resultobj = Py_None;
43947 return resultobj;
43948 fail:
43949 return NULL;
43950 }
43951
43952
43953 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43954 PyObject *resultobj;
43955 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43956 PyObject * obj0 = 0 ;
43957 char *kwnames[] = {
43958 (char *) "self", NULL
43959 };
43960
43961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43963 if (SWIG_arg_fail(1)) SWIG_fail;
43964 {
43965 PyThreadState* __tstate = wxPyBeginAllowThreads();
43966 (arg1)->Unconstrained();
43967
43968 wxPyEndAllowThreads(__tstate);
43969 if (PyErr_Occurred()) SWIG_fail;
43970 }
43971 Py_INCREF(Py_None); resultobj = Py_None;
43972 return resultobj;
43973 fail:
43974 return NULL;
43975 }
43976
43977
43978 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43979 PyObject *resultobj;
43980 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43981 PyObject * obj0 = 0 ;
43982 char *kwnames[] = {
43983 (char *) "self", NULL
43984 };
43985
43986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43988 if (SWIG_arg_fail(1)) SWIG_fail;
43989 {
43990 PyThreadState* __tstate = wxPyBeginAllowThreads();
43991 (arg1)->AsIs();
43992
43993 wxPyEndAllowThreads(__tstate);
43994 if (PyErr_Occurred()) SWIG_fail;
43995 }
43996 Py_INCREF(Py_None); resultobj = Py_None;
43997 return resultobj;
43998 fail:
43999 return NULL;
44000 }
44001
44002
44003 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44004 PyObject *resultobj;
44005 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44006 wxWindow *result;
44007 PyObject * obj0 = 0 ;
44008 char *kwnames[] = {
44009 (char *) "self", NULL
44010 };
44011
44012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44014 if (SWIG_arg_fail(1)) SWIG_fail;
44015 {
44016 PyThreadState* __tstate = wxPyBeginAllowThreads();
44017 result = (wxWindow *)(arg1)->GetOtherWindow();
44018
44019 wxPyEndAllowThreads(__tstate);
44020 if (PyErr_Occurred()) SWIG_fail;
44021 }
44022 {
44023 resultobj = wxPyMake_wxObject(result, 0);
44024 }
44025 return resultobj;
44026 fail:
44027 return NULL;
44028 }
44029
44030
44031 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44032 PyObject *resultobj;
44033 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44034 wxEdge result;
44035 PyObject * obj0 = 0 ;
44036 char *kwnames[] = {
44037 (char *) "self", NULL
44038 };
44039
44040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44042 if (SWIG_arg_fail(1)) SWIG_fail;
44043 {
44044 PyThreadState* __tstate = wxPyBeginAllowThreads();
44045 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44046
44047 wxPyEndAllowThreads(__tstate);
44048 if (PyErr_Occurred()) SWIG_fail;
44049 }
44050 resultobj = SWIG_From_int((result));
44051 return resultobj;
44052 fail:
44053 return NULL;
44054 }
44055
44056
44057 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44058 PyObject *resultobj;
44059 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44060 wxEdge arg2 ;
44061 PyObject * obj0 = 0 ;
44062 PyObject * obj1 = 0 ;
44063 char *kwnames[] = {
44064 (char *) "self",(char *) "which", NULL
44065 };
44066
44067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44069 if (SWIG_arg_fail(1)) SWIG_fail;
44070 {
44071 arg2 = (wxEdge)(SWIG_As_int(obj1));
44072 if (SWIG_arg_fail(2)) SWIG_fail;
44073 }
44074 {
44075 PyThreadState* __tstate = wxPyBeginAllowThreads();
44076 (arg1)->SetEdge((wxEdge )arg2);
44077
44078 wxPyEndAllowThreads(__tstate);
44079 if (PyErr_Occurred()) SWIG_fail;
44080 }
44081 Py_INCREF(Py_None); resultobj = Py_None;
44082 return resultobj;
44083 fail:
44084 return NULL;
44085 }
44086
44087
44088 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44089 PyObject *resultobj;
44090 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44091 int arg2 ;
44092 PyObject * obj0 = 0 ;
44093 PyObject * obj1 = 0 ;
44094 char *kwnames[] = {
44095 (char *) "self",(char *) "v", NULL
44096 };
44097
44098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44100 if (SWIG_arg_fail(1)) SWIG_fail;
44101 {
44102 arg2 = (int)(SWIG_As_int(obj1));
44103 if (SWIG_arg_fail(2)) SWIG_fail;
44104 }
44105 {
44106 PyThreadState* __tstate = wxPyBeginAllowThreads();
44107 (arg1)->SetValue(arg2);
44108
44109 wxPyEndAllowThreads(__tstate);
44110 if (PyErr_Occurred()) SWIG_fail;
44111 }
44112 Py_INCREF(Py_None); resultobj = Py_None;
44113 return resultobj;
44114 fail:
44115 return NULL;
44116 }
44117
44118
44119 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44120 PyObject *resultobj;
44121 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44122 int result;
44123 PyObject * obj0 = 0 ;
44124 char *kwnames[] = {
44125 (char *) "self", NULL
44126 };
44127
44128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44130 if (SWIG_arg_fail(1)) SWIG_fail;
44131 {
44132 PyThreadState* __tstate = wxPyBeginAllowThreads();
44133 result = (int)(arg1)->GetMargin();
44134
44135 wxPyEndAllowThreads(__tstate);
44136 if (PyErr_Occurred()) SWIG_fail;
44137 }
44138 {
44139 resultobj = SWIG_From_int((int)(result));
44140 }
44141 return resultobj;
44142 fail:
44143 return NULL;
44144 }
44145
44146
44147 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44148 PyObject *resultobj;
44149 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44150 int arg2 ;
44151 PyObject * obj0 = 0 ;
44152 PyObject * obj1 = 0 ;
44153 char *kwnames[] = {
44154 (char *) "self",(char *) "m", NULL
44155 };
44156
44157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44159 if (SWIG_arg_fail(1)) SWIG_fail;
44160 {
44161 arg2 = (int)(SWIG_As_int(obj1));
44162 if (SWIG_arg_fail(2)) SWIG_fail;
44163 }
44164 {
44165 PyThreadState* __tstate = wxPyBeginAllowThreads();
44166 (arg1)->SetMargin(arg2);
44167
44168 wxPyEndAllowThreads(__tstate);
44169 if (PyErr_Occurred()) SWIG_fail;
44170 }
44171 Py_INCREF(Py_None); resultobj = Py_None;
44172 return resultobj;
44173 fail:
44174 return NULL;
44175 }
44176
44177
44178 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44179 PyObject *resultobj;
44180 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44181 int result;
44182 PyObject * obj0 = 0 ;
44183 char *kwnames[] = {
44184 (char *) "self", NULL
44185 };
44186
44187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44189 if (SWIG_arg_fail(1)) SWIG_fail;
44190 {
44191 PyThreadState* __tstate = wxPyBeginAllowThreads();
44192 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44193
44194 wxPyEndAllowThreads(__tstate);
44195 if (PyErr_Occurred()) SWIG_fail;
44196 }
44197 {
44198 resultobj = SWIG_From_int((int)(result));
44199 }
44200 return resultobj;
44201 fail:
44202 return NULL;
44203 }
44204
44205
44206 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44207 PyObject *resultobj;
44208 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44209 int result;
44210 PyObject * obj0 = 0 ;
44211 char *kwnames[] = {
44212 (char *) "self", NULL
44213 };
44214
44215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44217 if (SWIG_arg_fail(1)) SWIG_fail;
44218 {
44219 PyThreadState* __tstate = wxPyBeginAllowThreads();
44220 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44221
44222 wxPyEndAllowThreads(__tstate);
44223 if (PyErr_Occurred()) SWIG_fail;
44224 }
44225 {
44226 resultobj = SWIG_From_int((int)(result));
44227 }
44228 return resultobj;
44229 fail:
44230 return NULL;
44231 }
44232
44233
44234 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44235 PyObject *resultobj;
44236 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44237 int result;
44238 PyObject * obj0 = 0 ;
44239 char *kwnames[] = {
44240 (char *) "self", NULL
44241 };
44242
44243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44245 if (SWIG_arg_fail(1)) SWIG_fail;
44246 {
44247 PyThreadState* __tstate = wxPyBeginAllowThreads();
44248 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44249
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 {
44254 resultobj = SWIG_From_int((int)(result));
44255 }
44256 return resultobj;
44257 fail:
44258 return NULL;
44259 }
44260
44261
44262 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44263 PyObject *resultobj;
44264 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44265 bool result;
44266 PyObject * obj0 = 0 ;
44267 char *kwnames[] = {
44268 (char *) "self", NULL
44269 };
44270
44271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44273 if (SWIG_arg_fail(1)) SWIG_fail;
44274 {
44275 PyThreadState* __tstate = wxPyBeginAllowThreads();
44276 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44277
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 {
44282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44283 }
44284 return resultobj;
44285 fail:
44286 return NULL;
44287 }
44288
44289
44290 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44291 PyObject *resultobj;
44292 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44293 bool arg2 ;
44294 PyObject * obj0 = 0 ;
44295 PyObject * obj1 = 0 ;
44296 char *kwnames[] = {
44297 (char *) "self",(char *) "d", NULL
44298 };
44299
44300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44302 if (SWIG_arg_fail(1)) SWIG_fail;
44303 {
44304 arg2 = (bool)(SWIG_As_bool(obj1));
44305 if (SWIG_arg_fail(2)) SWIG_fail;
44306 }
44307 {
44308 PyThreadState* __tstate = wxPyBeginAllowThreads();
44309 (arg1)->SetDone(arg2);
44310
44311 wxPyEndAllowThreads(__tstate);
44312 if (PyErr_Occurred()) SWIG_fail;
44313 }
44314 Py_INCREF(Py_None); resultobj = Py_None;
44315 return resultobj;
44316 fail:
44317 return NULL;
44318 }
44319
44320
44321 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44322 PyObject *resultobj;
44323 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44324 wxRelationship result;
44325 PyObject * obj0 = 0 ;
44326 char *kwnames[] = {
44327 (char *) "self", NULL
44328 };
44329
44330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44332 if (SWIG_arg_fail(1)) SWIG_fail;
44333 {
44334 PyThreadState* __tstate = wxPyBeginAllowThreads();
44335 result = (wxRelationship)(arg1)->GetRelationship();
44336
44337 wxPyEndAllowThreads(__tstate);
44338 if (PyErr_Occurred()) SWIG_fail;
44339 }
44340 resultobj = SWIG_From_int((result));
44341 return resultobj;
44342 fail:
44343 return NULL;
44344 }
44345
44346
44347 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44348 PyObject *resultobj;
44349 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44350 wxRelationship arg2 ;
44351 PyObject * obj0 = 0 ;
44352 PyObject * obj1 = 0 ;
44353 char *kwnames[] = {
44354 (char *) "self",(char *) "r", NULL
44355 };
44356
44357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44359 if (SWIG_arg_fail(1)) SWIG_fail;
44360 {
44361 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44362 if (SWIG_arg_fail(2)) SWIG_fail;
44363 }
44364 {
44365 PyThreadState* __tstate = wxPyBeginAllowThreads();
44366 (arg1)->SetRelationship((wxRelationship )arg2);
44367
44368 wxPyEndAllowThreads(__tstate);
44369 if (PyErr_Occurred()) SWIG_fail;
44370 }
44371 Py_INCREF(Py_None); resultobj = Py_None;
44372 return resultobj;
44373 fail:
44374 return NULL;
44375 }
44376
44377
44378 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44379 PyObject *resultobj;
44380 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44381 wxWindow *arg2 = (wxWindow *) 0 ;
44382 bool result;
44383 PyObject * obj0 = 0 ;
44384 PyObject * obj1 = 0 ;
44385 char *kwnames[] = {
44386 (char *) "self",(char *) "otherW", NULL
44387 };
44388
44389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44391 if (SWIG_arg_fail(1)) SWIG_fail;
44392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44393 if (SWIG_arg_fail(2)) SWIG_fail;
44394 {
44395 PyThreadState* __tstate = wxPyBeginAllowThreads();
44396 result = (bool)(arg1)->ResetIfWin(arg2);
44397
44398 wxPyEndAllowThreads(__tstate);
44399 if (PyErr_Occurred()) SWIG_fail;
44400 }
44401 {
44402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44403 }
44404 return resultobj;
44405 fail:
44406 return NULL;
44407 }
44408
44409
44410 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44411 PyObject *resultobj;
44412 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44413 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44414 wxWindow *arg3 = (wxWindow *) 0 ;
44415 bool result;
44416 PyObject * obj0 = 0 ;
44417 PyObject * obj1 = 0 ;
44418 PyObject * obj2 = 0 ;
44419 char *kwnames[] = {
44420 (char *) "self",(char *) "constraints",(char *) "win", NULL
44421 };
44422
44423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44425 if (SWIG_arg_fail(1)) SWIG_fail;
44426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44427 if (SWIG_arg_fail(2)) SWIG_fail;
44428 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44429 if (SWIG_arg_fail(3)) SWIG_fail;
44430 {
44431 PyThreadState* __tstate = wxPyBeginAllowThreads();
44432 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44433
44434 wxPyEndAllowThreads(__tstate);
44435 if (PyErr_Occurred()) SWIG_fail;
44436 }
44437 {
44438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44439 }
44440 return resultobj;
44441 fail:
44442 return NULL;
44443 }
44444
44445
44446 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44447 PyObject *resultobj;
44448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44449 wxEdge arg2 ;
44450 wxWindow *arg3 = (wxWindow *) 0 ;
44451 wxWindow *arg4 = (wxWindow *) 0 ;
44452 int result;
44453 PyObject * obj0 = 0 ;
44454 PyObject * obj1 = 0 ;
44455 PyObject * obj2 = 0 ;
44456 PyObject * obj3 = 0 ;
44457 char *kwnames[] = {
44458 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44459 };
44460
44461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44463 if (SWIG_arg_fail(1)) SWIG_fail;
44464 {
44465 arg2 = (wxEdge)(SWIG_As_int(obj1));
44466 if (SWIG_arg_fail(2)) SWIG_fail;
44467 }
44468 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44469 if (SWIG_arg_fail(3)) SWIG_fail;
44470 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44471 if (SWIG_arg_fail(4)) SWIG_fail;
44472 {
44473 PyThreadState* __tstate = wxPyBeginAllowThreads();
44474 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44475
44476 wxPyEndAllowThreads(__tstate);
44477 if (PyErr_Occurred()) SWIG_fail;
44478 }
44479 {
44480 resultobj = SWIG_From_int((int)(result));
44481 }
44482 return resultobj;
44483 fail:
44484 return NULL;
44485 }
44486
44487
44488 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44489 PyObject *obj;
44490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44491 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44492 Py_INCREF(obj);
44493 return Py_BuildValue((char *)"");
44494 }
44495 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44496 PyObject *resultobj;
44497 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44498 wxIndividualLayoutConstraint *result;
44499 PyObject * obj0 = 0 ;
44500 char *kwnames[] = {
44501 (char *) "self", NULL
44502 };
44503
44504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44506 if (SWIG_arg_fail(1)) SWIG_fail;
44507 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44508
44509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44510 return resultobj;
44511 fail:
44512 return NULL;
44513 }
44514
44515
44516 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44517 PyObject *resultobj;
44518 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44519 wxIndividualLayoutConstraint *result;
44520 PyObject * obj0 = 0 ;
44521 char *kwnames[] = {
44522 (char *) "self", NULL
44523 };
44524
44525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44527 if (SWIG_arg_fail(1)) SWIG_fail;
44528 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44529
44530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44531 return resultobj;
44532 fail:
44533 return NULL;
44534 }
44535
44536
44537 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44538 PyObject *resultobj;
44539 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44540 wxIndividualLayoutConstraint *result;
44541 PyObject * obj0 = 0 ;
44542 char *kwnames[] = {
44543 (char *) "self", NULL
44544 };
44545
44546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44548 if (SWIG_arg_fail(1)) SWIG_fail;
44549 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44550
44551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44552 return resultobj;
44553 fail:
44554 return NULL;
44555 }
44556
44557
44558 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44559 PyObject *resultobj;
44560 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44561 wxIndividualLayoutConstraint *result;
44562 PyObject * obj0 = 0 ;
44563 char *kwnames[] = {
44564 (char *) "self", NULL
44565 };
44566
44567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44569 if (SWIG_arg_fail(1)) SWIG_fail;
44570 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44571
44572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44573 return resultobj;
44574 fail:
44575 return NULL;
44576 }
44577
44578
44579 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44580 PyObject *resultobj;
44581 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44582 wxIndividualLayoutConstraint *result;
44583 PyObject * obj0 = 0 ;
44584 char *kwnames[] = {
44585 (char *) "self", NULL
44586 };
44587
44588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44590 if (SWIG_arg_fail(1)) SWIG_fail;
44591 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44592
44593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44594 return resultobj;
44595 fail:
44596 return NULL;
44597 }
44598
44599
44600 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44601 PyObject *resultobj;
44602 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44603 wxIndividualLayoutConstraint *result;
44604 PyObject * obj0 = 0 ;
44605 char *kwnames[] = {
44606 (char *) "self", NULL
44607 };
44608
44609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44611 if (SWIG_arg_fail(1)) SWIG_fail;
44612 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44613
44614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44615 return resultobj;
44616 fail:
44617 return NULL;
44618 }
44619
44620
44621 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44622 PyObject *resultobj;
44623 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44624 wxIndividualLayoutConstraint *result;
44625 PyObject * obj0 = 0 ;
44626 char *kwnames[] = {
44627 (char *) "self", NULL
44628 };
44629
44630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44632 if (SWIG_arg_fail(1)) SWIG_fail;
44633 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44634
44635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44636 return resultobj;
44637 fail:
44638 return NULL;
44639 }
44640
44641
44642 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44643 PyObject *resultobj;
44644 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44645 wxIndividualLayoutConstraint *result;
44646 PyObject * obj0 = 0 ;
44647 char *kwnames[] = {
44648 (char *) "self", NULL
44649 };
44650
44651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44653 if (SWIG_arg_fail(1)) SWIG_fail;
44654 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44655
44656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44657 return resultobj;
44658 fail:
44659 return NULL;
44660 }
44661
44662
44663 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44664 PyObject *resultobj;
44665 wxLayoutConstraints *result;
44666 char *kwnames[] = {
44667 NULL
44668 };
44669
44670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44671 {
44672 PyThreadState* __tstate = wxPyBeginAllowThreads();
44673 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44674
44675 wxPyEndAllowThreads(__tstate);
44676 if (PyErr_Occurred()) SWIG_fail;
44677 }
44678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44679 return resultobj;
44680 fail:
44681 return NULL;
44682 }
44683
44684
44685 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44686 PyObject *resultobj;
44687 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44688 wxWindow *arg2 = (wxWindow *) 0 ;
44689 int *arg3 = (int *) 0 ;
44690 bool result;
44691 int temp3 ;
44692 int res3 = 0 ;
44693 PyObject * obj0 = 0 ;
44694 PyObject * obj1 = 0 ;
44695 char *kwnames[] = {
44696 (char *) "self",(char *) "win", NULL
44697 };
44698
44699 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44702 if (SWIG_arg_fail(1)) SWIG_fail;
44703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44704 if (SWIG_arg_fail(2)) SWIG_fail;
44705 {
44706 PyThreadState* __tstate = wxPyBeginAllowThreads();
44707 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44708
44709 wxPyEndAllowThreads(__tstate);
44710 if (PyErr_Occurred()) SWIG_fail;
44711 }
44712 {
44713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44714 }
44715 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44716 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44717 return resultobj;
44718 fail:
44719 return NULL;
44720 }
44721
44722
44723 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44724 PyObject *resultobj;
44725 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44726 bool result;
44727 PyObject * obj0 = 0 ;
44728 char *kwnames[] = {
44729 (char *) "self", NULL
44730 };
44731
44732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44734 if (SWIG_arg_fail(1)) SWIG_fail;
44735 {
44736 PyThreadState* __tstate = wxPyBeginAllowThreads();
44737 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44738
44739 wxPyEndAllowThreads(__tstate);
44740 if (PyErr_Occurred()) SWIG_fail;
44741 }
44742 {
44743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44744 }
44745 return resultobj;
44746 fail:
44747 return NULL;
44748 }
44749
44750
44751 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44752 PyObject *obj;
44753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44754 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44755 Py_INCREF(obj);
44756 return Py_BuildValue((char *)"");
44757 }
44758 static PyMethodDef SwigMethods[] = {
44759 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44760 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44761 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44764 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44785 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44798 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44813 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44866 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44894 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44913 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44915 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44923 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44924 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44936 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44948 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44952 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44958 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44968 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44978 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44982 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45057 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45059 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45061 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45063 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45065 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45067 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45069 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45071 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45073 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45075 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45077 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45079 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45081 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45095 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45113 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45116 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45119 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45131 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45136 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45142 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45148 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45211 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45218 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45254 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45264 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45270 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45272 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45274 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45277 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45281 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45284 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45287 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45289 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45294 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45302 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45306 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45309 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45311 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45315 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45332 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45334 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45337 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45339 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45343 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45347 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45358 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45361 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45364 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45368 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45375 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45380 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45385 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45389 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45434 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45454 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45461 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45465 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45475 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45645 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45687 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45701 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45704 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45759 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45786 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45830 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45838 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45857 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45858 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45895 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45925 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45928 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45932 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45935 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45945 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45957 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45969 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45979 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45989 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46003 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46010 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46011 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46012 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46013 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46014 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46019 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46046 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46058 { NULL, NULL, 0, NULL }
46059 };
46060
46061
46062 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46063
46064 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46065 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46066 }
46067 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46068 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46069 }
46070 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46071 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46072 }
46073 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46074 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46075 }
46076 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46077 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46078 }
46079 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46080 return (void *)((wxSizer *) ((wxGridSizer *) x));
46081 }
46082 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46083 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46084 }
46085 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46086 return (void *)((wxSizer *) ((wxPySizer *) x));
46087 }
46088 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46089 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46090 }
46091 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46092 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46093 }
46094 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46095 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46096 }
46097 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46098 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46099 }
46100 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46101 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46102 }
46103 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46104 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46105 }
46106 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46107 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46108 }
46109 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46110 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46111 }
46112 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46113 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46114 }
46115 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46116 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46117 }
46118 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46119 return (void *)((wxEvent *) ((wxPyEvent *) x));
46120 }
46121 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46122 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46123 }
46124 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46125 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46126 }
46127 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46128 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46129 }
46130 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46131 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46132 }
46133 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46134 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46135 }
46136 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46137 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46138 }
46139 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46140 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46141 }
46142 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46143 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46144 }
46145 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46146 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46147 }
46148 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46149 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46150 }
46151 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46152 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46153 }
46154 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46155 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46156 }
46157 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46158 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46159 }
46160 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46161 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46162 }
46163 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46164 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46165 }
46166 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46167 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46168 }
46169 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46170 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46171 }
46172 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46173 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46174 }
46175 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46176 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46177 }
46178 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46179 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46180 }
46181 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46182 return (void *)((wxEvent *) ((wxShowEvent *) x));
46183 }
46184 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46185 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46186 }
46187 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46188 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46189 }
46190 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46191 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46192 }
46193 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46194 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46195 }
46196 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46197 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46198 }
46199 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46200 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46201 }
46202 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46203 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46204 }
46205 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46206 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46207 }
46208 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46209 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46210 }
46211 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46212 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46213 }
46214 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46215 return (void *)((wxControl *) ((wxControlWithItems *) x));
46216 }
46217 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46218 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46219 }
46220 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46221 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46222 }
46223 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46224 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46225 }
46226 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46227 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46228 }
46229 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46230 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46231 }
46232 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46233 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46234 }
46235 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46236 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46237 }
46238 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46239 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46240 }
46241 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46242 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46243 }
46244 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46245 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46246 }
46247 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46248 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46249 }
46250 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46251 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46252 }
46253 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46254 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46255 }
46256 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46257 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46258 }
46259 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46260 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46261 }
46262 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46263 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46264 }
46265 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46266 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46267 }
46268 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46269 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46270 }
46271 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46272 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46273 }
46274 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46275 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46276 }
46277 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46278 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46279 }
46280 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46281 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46282 }
46283 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46284 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46285 }
46286 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46287 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46288 }
46289 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46290 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46291 }
46292 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46293 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46294 }
46295 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46296 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46297 }
46298 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46299 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46300 }
46301 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46302 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46303 }
46304 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46305 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46306 }
46307 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46308 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46309 }
46310 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46311 return (void *)((wxObject *) ((wxSizerItem *) x));
46312 }
46313 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46314 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46315 }
46316 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46317 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46318 }
46319 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46320 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46321 }
46322 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46323 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46324 }
46325 static void *_p_wxSizerTo_p_wxObject(void *x) {
46326 return (void *)((wxObject *) ((wxSizer *) x));
46327 }
46328 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46329 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46330 }
46331 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46332 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46333 }
46334 static void *_p_wxEventTo_p_wxObject(void *x) {
46335 return (void *)((wxObject *) ((wxEvent *) x));
46336 }
46337 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46338 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46339 }
46340 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46341 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46342 }
46343 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46344 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46345 }
46346 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46347 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46348 }
46349 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46350 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46351 }
46352 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46353 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46354 }
46355 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46356 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46357 }
46358 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46359 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46360 }
46361 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46362 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46363 }
46364 static void *_p_wxControlTo_p_wxObject(void *x) {
46365 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46366 }
46367 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46368 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46369 }
46370 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46371 return (void *)((wxObject *) ((wxFSFile *) x));
46372 }
46373 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46374 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46375 }
46376 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46377 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46378 }
46379 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46380 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46381 }
46382 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46383 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46384 }
46385 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46386 return (void *)((wxObject *) ((wxMenuItem *) x));
46387 }
46388 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46389 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46390 }
46391 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46392 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46393 }
46394 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46395 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46396 }
46397 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46398 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46399 }
46400 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46401 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46402 }
46403 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46404 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46405 }
46406 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46407 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46408 }
46409 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46410 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46411 }
46412 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46413 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46414 }
46415 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46416 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46417 }
46418 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46419 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46420 }
46421 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46422 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46423 }
46424 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46425 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46426 }
46427 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46428 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46429 }
46430 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46431 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46432 }
46433 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46434 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46435 }
46436 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46437 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46438 }
46439 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46440 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46441 }
46442 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46443 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46444 }
46445 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46446 return (void *)((wxObject *) ((wxImageHandler *) x));
46447 }
46448 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46449 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46450 }
46451 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46452 return (void *)((wxObject *) ((wxEvtHandler *) x));
46453 }
46454 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46455 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46456 }
46457 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46458 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46459 }
46460 static void *_p_wxImageTo_p_wxObject(void *x) {
46461 return (void *)((wxObject *) ((wxImage *) x));
46462 }
46463 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46464 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46465 }
46466 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46467 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46468 }
46469 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46470 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46471 }
46472 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46473 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46474 }
46475 static void *_p_wxWindowTo_p_wxObject(void *x) {
46476 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46477 }
46478 static void *_p_wxMenuTo_p_wxObject(void *x) {
46479 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46480 }
46481 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46482 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46483 }
46484 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46485 return (void *)((wxObject *) ((wxFileSystem *) x));
46486 }
46487 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46489 }
46490 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46491 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46492 }
46493 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46494 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46495 }
46496 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46497 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46498 }
46499 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46500 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46501 }
46502 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46503 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46504 }
46505 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46506 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46507 }
46508 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46509 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46510 }
46511 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46512 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46513 }
46514 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46515 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46516 }
46517 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46518 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46519 }
46520 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46521 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46522 }
46523 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46524 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46525 }
46526 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46527 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46528 }
46529 static void *_p_wxControlTo_p_wxWindow(void *x) {
46530 return (void *)((wxWindow *) ((wxControl *) x));
46531 }
46532 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46533 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46534 }
46535 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46536 return (void *)((wxWindow *) ((wxMenuBar *) x));
46537 }
46538 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46539 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46540 }
46541 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46542 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46543 }
46544 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46545 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46546 }
46547 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46548 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46549 }
46550 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46551 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46552 }
46553 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46554 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46555 }
46556 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46557 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46558 }
46559 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46560 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46561 }
46562 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46563 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46564 }
46565 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46566 return (void *)((wxValidator *) ((wxPyValidator *) x));
46567 }
46568 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}};
46569 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}};
46570 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}};
46571 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}};
46572 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}};
46573 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}};
46574 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}};
46575 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}};
46576 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}};
46577 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}};
46578 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}};
46579 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}};
46580 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}};
46581 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46582 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}};
46583 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}};
46584 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}};
46585 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}};
46586 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}};
46587 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}};
46588 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}};
46589 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}};
46590 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}};
46591 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}};
46592 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}};
46593 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}};
46594 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}};
46595 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}};
46596 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}};
46597 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}};
46598 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}};
46599 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}};
46600 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}};
46601 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}};
46602 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}};
46603 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}};
46604 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}};
46605 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}};
46606 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}};
46607 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}};
46608 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}};
46609 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}};
46610 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}};
46611 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}};
46612 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}};
46613 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}};
46614 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}};
46615 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}};
46616 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}};
46617 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}};
46618 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}};
46619 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}};
46620 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}};
46621 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}};
46622 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}};
46623 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}};
46624 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46625 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}};
46626 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}};
46627 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}};
46628 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}};
46629 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}};
46630 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}};
46631 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}};
46632 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}};
46633 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}};
46634 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}};
46635 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}};
46636 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}};
46637 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}};
46638 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}};
46639 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}};
46640 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}};
46641 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}};
46642 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}};
46643 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}};
46644 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}};
46645 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}};
46646 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}};
46647 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}};
46648 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}};
46649 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}};
46650 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}};
46651 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}};
46652 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}};
46653 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}};
46654 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}};
46655 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}};
46656 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}};
46657 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}};
46658 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}};
46659 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}};
46660 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}};
46661 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}};
46662 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46663 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}};
46664 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}};
46665 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}};
46666 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}};
46667 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}};
46668 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}};
46669 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}};
46670 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}};
46671 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}};
46672 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}};
46673 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}};
46674 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}};
46675 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}};
46676 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}};
46677 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}};
46678 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}};
46679 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}};
46680 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}};
46681 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}};
46682 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}};
46683 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}};
46684 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46685 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}};
46686 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}};
46687 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}};
46688 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}};
46689 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}};
46690 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}};
46691 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}};
46692 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}};
46693 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}};
46694 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}};
46695
46696 static swig_type_info *swig_types_initial[] = {
46697 _swigt__p_wxLayoutConstraints,
46698 _swigt__p_wxRealPoint,
46699 _swigt__p_wxSizerItem,
46700 _swigt__p_wxGBSizerItem,
46701 _swigt__p_wxScrollEvent,
46702 _swigt__p_wxEventLoop,
46703 _swigt__p_wxIndividualLayoutConstraint,
46704 _swigt__p_wxSizer,
46705 _swigt__p_wxBoxSizer,
46706 _swigt__p_wxStaticBoxSizer,
46707 _swigt__p_wxGridBagSizer,
46708 _swigt__p_wxAcceleratorEntry,
46709 _swigt__p_wxUpdateUIEvent,
46710 _swigt__p_wxEvent,
46711 _swigt__p_wxMenu,
46712 _swigt__p_wxGridSizer,
46713 _swigt__p_wxFlexGridSizer,
46714 _swigt__p_wxInitDialogEvent,
46715 _swigt__p_wxItemContainer,
46716 _swigt__p_wxNcPaintEvent,
46717 _swigt__p_wxPaintEvent,
46718 _swigt__p_wxSysColourChangedEvent,
46719 _swigt__p_wxMouseCaptureChangedEvent,
46720 _swigt__p_wxDisplayChangedEvent,
46721 _swigt__p_wxPaletteChangedEvent,
46722 _swigt__p_wxControl,
46723 _swigt__p_wxFont,
46724 _swigt__p_wxMenuBarBase,
46725 _swigt__p_wxSetCursorEvent,
46726 _swigt__p_wxFSFile,
46727 _swigt__p_wxCaret,
46728 _swigt__ptrdiff_t,
46729 _swigt__std__ptrdiff_t,
46730 _swigt__p_wxRegion,
46731 _swigt__p_wxPoint2D,
46732 _swigt__p_int,
46733 _swigt__p_wxSize,
46734 _swigt__p_wxDC,
46735 _swigt__p_wxPySizer,
46736 _swigt__p_wxVisualAttributes,
46737 _swigt__p_wxNotifyEvent,
46738 _swigt__p_wxPyEvent,
46739 _swigt__p_wxPropagationDisabler,
46740 _swigt__p_form_ops_t,
46741 _swigt__p_wxAppTraits,
46742 _swigt__p_wxArrayString,
46743 _swigt__p_wxShowEvent,
46744 _swigt__p_wxToolTip,
46745 _swigt__p_wxMoveEvent,
46746 _swigt__p_wxSizeEvent,
46747 _swigt__p_wxActivateEvent,
46748 _swigt__p_wxIconizeEvent,
46749 _swigt__p_wxMaximizeEvent,
46750 _swigt__p_wxQueryNewPaletteEvent,
46751 _swigt__p_wxWindowCreateEvent,
46752 _swigt__p_wxIdleEvent,
46753 _swigt__p_wxDateEvent,
46754 _swigt__p_wxMenuItem,
46755 _swigt__p_wxStaticBox,
46756 _swigt__p_long,
46757 _swigt__p_wxDuplexMode,
46758 _swigt__p_wxTIFFHandler,
46759 _swigt__p_wxXPMHandler,
46760 _swigt__p_wxPNMHandler,
46761 _swigt__p_wxJPEGHandler,
46762 _swigt__p_wxPCXHandler,
46763 _swigt__p_wxGIFHandler,
46764 _swigt__p_wxPNGHandler,
46765 _swigt__p_wxANIHandler,
46766 _swigt__p_wxMemoryFSHandler,
46767 _swigt__p_wxZipFSHandler,
46768 _swigt__p_wxInternetFSHandler,
46769 _swigt__p_wxPyFileSystemHandler,
46770 _swigt__p_wxEvtHandler,
46771 _swigt__p_wxCURHandler,
46772 _swigt__p_wxICOHandler,
46773 _swigt__p_wxBMPHandler,
46774 _swigt__p_wxImageHandler,
46775 _swigt__p_wxFileSystemHandler,
46776 _swigt__p_wxRect,
46777 _swigt__p_wxButton,
46778 _swigt__p_wxGBSpan,
46779 _swigt__p_wxPropagateOnce,
46780 _swigt__p_wxAcceleratorTable,
46781 _swigt__p_wxStdDialogButtonSizer,
46782 _swigt__p_char,
46783 _swigt__p_wxGBPosition,
46784 _swigt__p_wxImage,
46785 _swigt__p_wxFrame,
46786 _swigt__p_wxScrollWinEvent,
46787 _swigt__p_wxPaperSize,
46788 _swigt__p_wxImageHistogram,
46789 _swigt__p_wxPoint,
46790 _swigt__p_wxCursor,
46791 _swigt__p_wxObject,
46792 _swigt__p_wxInputStream,
46793 _swigt__p_wxOutputStream,
46794 _swigt__p_wxPyInputStream,
46795 _swigt__p_wxDateTime,
46796 _swigt__p_wxKeyEvent,
46797 _swigt__p_wxNavigationKeyEvent,
46798 _swigt__p_wxWindowDestroyEvent,
46799 _swigt__p_unsigned_long,
46800 _swigt__p_wxWindow,
46801 _swigt__p_wxMenuBar,
46802 _swigt__p_wxFileSystem,
46803 _swigt__p_wxBitmap,
46804 _swigt__unsigned_int,
46805 _swigt__p_unsigned_int,
46806 _swigt__p_wxMenuEvent,
46807 _swigt__p_wxContextMenuEvent,
46808 _swigt__p_unsigned_char,
46809 _swigt__p_wxEraseEvent,
46810 _swigt__p_wxMouseEvent,
46811 _swigt__p_wxCloseEvent,
46812 _swigt__p_wxPyApp,
46813 _swigt__p_wxCommandEvent,
46814 _swigt__p_wxPyCommandEvent,
46815 _swigt__p_wxPyDropTarget,
46816 _swigt__p_wxQuantize,
46817 _swigt__p_wxChildFocusEvent,
46818 _swigt__p_wxFocusEvent,
46819 _swigt__p_wxDropFilesEvent,
46820 _swigt__p_wxControlWithItems,
46821 _swigt__p_wxColour,
46822 _swigt__p_wxValidator,
46823 _swigt__p_wxPyValidator,
46824 0
46825 };
46826
46827
46828 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46829
46830 static swig_const_info swig_const_table[] = {
46831 {0, 0, 0, 0.0, 0, 0}};
46832
46833 #ifdef __cplusplus
46834 }
46835 #endif
46836
46837
46838 #ifdef __cplusplus
46839 extern "C" {
46840 #endif
46841
46842 /* Python-specific SWIG API */
46843 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46844 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46845 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46846
46847 /* -----------------------------------------------------------------------------
46848 * global variable support code.
46849 * ----------------------------------------------------------------------------- */
46850
46851 typedef struct swig_globalvar {
46852 char *name; /* Name of global variable */
46853 PyObject *(*get_attr)(); /* Return the current value */
46854 int (*set_attr)(PyObject *); /* Set the value */
46855 struct swig_globalvar *next;
46856 } swig_globalvar;
46857
46858 typedef struct swig_varlinkobject {
46859 PyObject_HEAD
46860 swig_globalvar *vars;
46861 } swig_varlinkobject;
46862
46863 static PyObject *
46864 swig_varlink_repr(swig_varlinkobject *v) {
46865 v = v;
46866 return PyString_FromString("<Swig global variables>");
46867 }
46868
46869 static int
46870 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46871 swig_globalvar *var;
46872 flags = flags;
46873 fprintf(fp,"Swig global variables { ");
46874 for (var = v->vars; var; var=var->next) {
46875 fprintf(fp,"%s", var->name);
46876 if (var->next) fprintf(fp,", ");
46877 }
46878 fprintf(fp," }\n");
46879 return 0;
46880 }
46881
46882 static PyObject *
46883 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46884 swig_globalvar *var = v->vars;
46885 while (var) {
46886 if (strcmp(var->name,n) == 0) {
46887 return (*var->get_attr)();
46888 }
46889 var = var->next;
46890 }
46891 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46892 return NULL;
46893 }
46894
46895 static int
46896 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46897 swig_globalvar *var = v->vars;
46898 while (var) {
46899 if (strcmp(var->name,n) == 0) {
46900 return (*var->set_attr)(p);
46901 }
46902 var = var->next;
46903 }
46904 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46905 return 1;
46906 }
46907
46908 static PyTypeObject varlinktype = {
46909 PyObject_HEAD_INIT(0)
46910 0, /* Number of items in variable part (ob_size) */
46911 (char *)"swigvarlink", /* Type name (tp_name) */
46912 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46913 0, /* Itemsize (tp_itemsize) */
46914 0, /* Deallocator (tp_dealloc) */
46915 (printfunc) swig_varlink_print, /* Print (tp_print) */
46916 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46917 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46918 0, /* tp_compare */
46919 (reprfunc) swig_varlink_repr, /* tp_repr */
46920 0, /* tp_as_number */
46921 0, /* tp_as_sequence */
46922 0, /* tp_as_mapping */
46923 0, /* tp_hash */
46924 0, /* tp_call */
46925 0, /* tp_str */
46926 0, /* tp_getattro */
46927 0, /* tp_setattro */
46928 0, /* tp_as_buffer */
46929 0, /* tp_flags */
46930 0, /* tp_doc */
46931 #if PY_VERSION_HEX >= 0x02000000
46932 0, /* tp_traverse */
46933 0, /* tp_clear */
46934 #endif
46935 #if PY_VERSION_HEX >= 0x02010000
46936 0, /* tp_richcompare */
46937 0, /* tp_weaklistoffset */
46938 #endif
46939 #if PY_VERSION_HEX >= 0x02020000
46940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46941 #endif
46942 #if PY_VERSION_HEX >= 0x02030000
46943 0, /* tp_del */
46944 #endif
46945 #ifdef COUNT_ALLOCS
46946 0,0,0,0 /* tp_alloc -> tp_next */
46947 #endif
46948 };
46949
46950 /* Create a variable linking object for use later */
46951 static PyObject *
46952 SWIG_Python_newvarlink(void) {
46953 swig_varlinkobject *result = 0;
46954 result = PyMem_NEW(swig_varlinkobject,1);
46955 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46956 result->ob_type = &varlinktype;
46957 result->vars = 0;
46958 result->ob_refcnt = 0;
46959 Py_XINCREF((PyObject *) result);
46960 return ((PyObject*) result);
46961 }
46962
46963 static void
46964 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46965 swig_varlinkobject *v;
46966 swig_globalvar *gv;
46967 v= (swig_varlinkobject *) p;
46968 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46969 gv->name = (char *) malloc(strlen(name)+1);
46970 strcpy(gv->name,name);
46971 gv->get_attr = get_attr;
46972 gv->set_attr = set_attr;
46973 gv->next = v->vars;
46974 v->vars = gv;
46975 }
46976
46977 /* -----------------------------------------------------------------------------
46978 * constants/methods manipulation
46979 * ----------------------------------------------------------------------------- */
46980
46981 /* Install Constants */
46982 static void
46983 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46984 PyObject *obj = 0;
46985 size_t i;
46986 for (i = 0; constants[i].type; i++) {
46987 switch(constants[i].type) {
46988 case SWIG_PY_INT:
46989 obj = PyInt_FromLong(constants[i].lvalue);
46990 break;
46991 case SWIG_PY_FLOAT:
46992 obj = PyFloat_FromDouble(constants[i].dvalue);
46993 break;
46994 case SWIG_PY_STRING:
46995 if (constants[i].pvalue) {
46996 obj = PyString_FromString((char *) constants[i].pvalue);
46997 } else {
46998 Py_INCREF(Py_None);
46999 obj = Py_None;
47000 }
47001 break;
47002 case SWIG_PY_POINTER:
47003 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47004 break;
47005 case SWIG_PY_BINARY:
47006 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47007 break;
47008 default:
47009 obj = 0;
47010 break;
47011 }
47012 if (obj) {
47013 PyDict_SetItemString(d,constants[i].name,obj);
47014 Py_DECREF(obj);
47015 }
47016 }
47017 }
47018
47019 /* -----------------------------------------------------------------------------*/
47020 /* Fix SwigMethods to carry the callback ptrs when needed */
47021 /* -----------------------------------------------------------------------------*/
47022
47023 static void
47024 SWIG_Python_FixMethods(PyMethodDef *methods,
47025 swig_const_info *const_table,
47026 swig_type_info **types,
47027 swig_type_info **types_initial) {
47028 size_t i;
47029 for (i = 0; methods[i].ml_name; ++i) {
47030 char *c = methods[i].ml_doc;
47031 if (c && (c = strstr(c, "swig_ptr: "))) {
47032 int j;
47033 swig_const_info *ci = 0;
47034 char *name = c + 10;
47035 for (j = 0; const_table[j].type; j++) {
47036 if (strncmp(const_table[j].name, name,
47037 strlen(const_table[j].name)) == 0) {
47038 ci = &(const_table[j]);
47039 break;
47040 }
47041 }
47042 if (ci) {
47043 size_t shift = (ci->ptype) - types;
47044 swig_type_info *ty = types_initial[shift];
47045 size_t ldoc = (c - methods[i].ml_doc);
47046 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47047 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47048 char *buff = ndoc;
47049 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47050 strncpy(buff, methods[i].ml_doc, ldoc);
47051 buff += ldoc;
47052 strncpy(buff, "swig_ptr: ", 10);
47053 buff += 10;
47054 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47055 methods[i].ml_doc = ndoc;
47056 }
47057 }
47058 }
47059 }
47060
47061 /* -----------------------------------------------------------------------------*
47062 * Initialize type list
47063 * -----------------------------------------------------------------------------*/
47064
47065 #if PY_MAJOR_VERSION < 2
47066 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47067 is copied out of Python/modsupport.c in python version 2.3.4 */
47068 static int
47069 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47070 {
47071 PyObject *dict;
47072 if (!PyModule_Check(m)) {
47073 PyErr_SetString(PyExc_TypeError,
47074 "PyModule_AddObject() needs module as first arg");
47075 return -1;
47076 }
47077 if (!o) {
47078 PyErr_SetString(PyExc_TypeError,
47079 "PyModule_AddObject() needs non-NULL value");
47080 return -1;
47081 }
47082
47083 dict = PyModule_GetDict(m);
47084 if (dict == NULL) {
47085 /* Internal error -- modules must have a dict! */
47086 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47087 PyModule_GetName(m));
47088 return -1;
47089 }
47090 if (PyDict_SetItemString(dict, name, o))
47091 return -1;
47092 Py_DECREF(o);
47093 return 0;
47094 }
47095 #endif
47096
47097 static swig_type_info **
47098 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47099 static PyMethodDef swig_empty_runtime_method_table[] = {
47100 {
47101 NULL, NULL, 0, NULL
47102 }
47103 };/* Sentinel */
47104
47105 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47106 swig_empty_runtime_method_table);
47107 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47108 if (pointer && module) {
47109 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47110 }
47111 return type_list_handle;
47112 }
47113
47114 static swig_type_info **
47115 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47116 swig_type_info **type_pointer;
47117
47118 /* first check if module already created */
47119 type_pointer = SWIG_Python_GetTypeListHandle();
47120 if (type_pointer) {
47121 return type_pointer;
47122 } else {
47123 /* create a new module and variable */
47124 return SWIG_Python_SetTypeListHandle(type_list_handle);
47125 }
47126 }
47127
47128 #ifdef __cplusplus
47129 }
47130 #endif
47131
47132 /* -----------------------------------------------------------------------------*
47133 * Partial Init method
47134 * -----------------------------------------------------------------------------*/
47135
47136 #ifdef SWIG_LINK_RUNTIME
47137 #ifdef __cplusplus
47138 extern "C"
47139 #endif
47140 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47141 #endif
47142
47143 #ifdef __cplusplus
47144 extern "C"
47145 #endif
47146 SWIGEXPORT(void) SWIG_init(void) {
47147 static PyObject *SWIG_globals = 0;
47148 static int typeinit = 0;
47149 PyObject *m, *d;
47150 int i;
47151 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47152
47153 /* Fix SwigMethods to carry the callback ptrs when needed */
47154 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47155
47156 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47157 d = PyModule_GetDict(m);
47158
47159 if (!typeinit) {
47160 #ifdef SWIG_LINK_RUNTIME
47161 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47162 #else
47163 # ifndef SWIG_STATIC_RUNTIME
47164 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47165 # endif
47166 #endif
47167 for (i = 0; swig_types_initial[i]; i++) {
47168 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47169 }
47170 typeinit = 1;
47171 }
47172 SWIG_InstallConstants(d,swig_const_table);
47173
47174
47175 #ifndef wxPyUSE_EXPORT
47176 // Make our API structure a CObject so other modules can import it
47177 // from this module.
47178 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47179 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47180 Py_XDECREF(cobj);
47181 #endif
47182
47183 {
47184 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47185 }
47186 {
47187 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47188 }
47189 {
47190 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47191 }
47192 {
47193 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47194 }
47195 {
47196 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47197 }
47198 {
47199 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47200 }
47201 {
47202 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47203 }
47204 {
47205 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47206 }
47207 {
47208 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47209 }
47210 {
47211 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47212 }
47213 {
47214 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47215 }
47216 {
47217 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47218 }
47219 {
47220 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47221 }
47222 {
47223 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47224 }
47225 {
47226 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47227 }
47228 {
47229 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47230 }
47231 {
47232 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47233 }
47234 {
47235 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47236 }
47237 {
47238 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47239 }
47240 {
47241 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47242 }
47243 {
47244 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47245 }
47246 {
47247 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47248 }
47249 {
47250 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47251 }
47252 {
47253 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47254 }
47255 {
47256 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47257 }
47258 {
47259 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47260 }
47261 {
47262 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47263 }
47264 {
47265 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47266 }
47267 {
47268 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47269 }
47270 {
47271 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47272 }
47273 {
47274 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47275 }
47276 {
47277 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47278 }
47279 {
47280 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47281 }
47282 {
47283 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47284 }
47285 {
47286 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47287 }
47288 {
47289 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47290 }
47291 {
47292 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47293 }
47294 {
47295 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47296 }
47297 {
47298 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47299 }
47300 {
47301 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47302 }
47303 {
47304 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47305 }
47306 {
47307 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47308 }
47309 {
47310 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47311 }
47312 {
47313 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47314 }
47315 {
47316 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47317 }
47318 {
47319 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47320 }
47321 {
47322 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47323 }
47324 {
47325 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47326 }
47327 {
47328 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47329 }
47330 {
47331 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47332 }
47333 {
47334 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47335 }
47336 {
47337 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47338 }
47339 {
47340 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47341 }
47342 {
47343 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47344 }
47345 {
47346 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47347 }
47348 {
47349 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47350 }
47351 {
47352 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47353 }
47354 {
47355 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47356 }
47357 {
47358 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47359 }
47360 {
47361 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47362 }
47363 {
47364 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47365 }
47366 {
47367 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47368 }
47369 {
47370 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47371 }
47372 {
47373 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47374 }
47375 {
47376 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47377 }
47378 {
47379 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47380 }
47381 {
47382 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47383 }
47384 {
47385 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47386 }
47387 {
47388 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47389 }
47390 {
47391 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47392 }
47393 {
47394 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47395 }
47396 {
47397 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47398 }
47399 {
47400 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47401 }
47402 {
47403 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47404 }
47405 {
47406 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47407 }
47408 {
47409 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47410 }
47411 {
47412 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47413 }
47414 {
47415 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47416 }
47417 {
47418 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47419 }
47420 {
47421 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47422 }
47423 {
47424 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47425 }
47426 {
47427 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47428 }
47429 {
47430 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47431 }
47432 {
47433 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47434 }
47435 {
47436 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47437 }
47438 {
47439 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47440 }
47441 {
47442 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47443 }
47444 {
47445 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47446 }
47447 {
47448 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47449 }
47450 {
47451 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47452 }
47453 {
47454 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47455 }
47456 {
47457 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47458 }
47459 {
47460 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47461 }
47462 {
47463 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47464 }
47465 {
47466 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47467 }
47468 {
47469 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47470 }
47471 {
47472 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47473 }
47474 {
47475 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47476 }
47477 {
47478 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47479 }
47480 {
47481 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47482 }
47483 {
47484 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47485 }
47486 {
47487 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47488 }
47489 {
47490 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47491 }
47492 {
47493 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47494 }
47495 {
47496 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47497 }
47498 {
47499 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47500 }
47501 {
47502 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47503 }
47504 {
47505 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47506 }
47507 {
47508 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47509 }
47510 {
47511 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47512 }
47513 {
47514 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47515 }
47516 {
47517 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47518 }
47519 {
47520 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47521 }
47522 {
47523 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47524 }
47525 {
47526 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47527 }
47528 {
47529 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47530 }
47531 {
47532 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47533 }
47534 {
47535 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47536 }
47537 {
47538 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47539 }
47540 {
47541 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47542 }
47543 {
47544 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47545 }
47546 {
47547 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47548 }
47549 {
47550 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47551 }
47552 {
47553 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47554 }
47555 {
47556 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47557 }
47558 {
47559 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47560 }
47561 {
47562 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47563 }
47564 {
47565 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47566 }
47567 {
47568 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47569 }
47570 {
47571 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47572 }
47573 {
47574 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47575 }
47576 {
47577 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47578 }
47579 {
47580 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47581 }
47582 {
47583 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47584 }
47585 {
47586 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47587 }
47588 {
47589 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47590 }
47591 {
47592 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47593 }
47594 {
47595 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47596 }
47597 {
47598 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47599 }
47600 {
47601 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47602 }
47603 {
47604 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47605 }
47606 {
47607 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47608 }
47609 {
47610 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47611 }
47612 {
47613 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47614 }
47615 {
47616 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47617 }
47618 {
47619 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47620 }
47621 {
47622 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47623 }
47624 {
47625 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47626 }
47627 {
47628 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47629 }
47630 {
47631 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47632 }
47633 {
47634 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47635 }
47636 {
47637 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47638 }
47639 {
47640 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47641 }
47642 {
47643 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48787 }
48788 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48789 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48790 {
48791 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48942 }
48943 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48944 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48945 {
48946 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48953 }
48954
48955 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48956
48957
48958 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48959
48960 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48961 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
48962 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48963 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48964 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48965 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48966 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
48967 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
48968 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48969 {
48970 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48974 }
48975 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
48976 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
48977 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
48978 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
48979 {
48980 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49017 }
49018 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49019 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49020 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49021 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49022 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49023 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49024 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49025 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49026 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49027 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49028 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49029 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49030 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49031 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49032 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49033 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49034 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49035 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49036 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49037 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49038 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49039 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49040 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49041 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49042 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49043 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49044 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49045 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49046 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49047 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49048 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49049 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49050 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49051 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49052 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49053 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49054 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49055 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49056 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49057 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49058 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49059 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49060 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49061 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49062 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49063 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49064 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49065 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49066 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49067 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49068 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49069 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49070 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49071 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49072 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49073 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49074 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49075 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49076 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49077 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49078 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49079 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49080 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49081 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49082 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49083 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49084 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49085 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49086 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49087 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49088 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49089 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49090 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49091 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49092 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49093 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49094 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49095 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49096 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49097 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49098 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49099 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49100 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49101 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49102 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49103 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49104 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49105 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49106 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49107 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49108 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49109 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49110 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49111 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49112 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49113 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49114 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49115 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49116 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49117 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49118 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49119 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49120 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49121 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49122 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49123 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49124 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49125 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49126 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49127 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49128 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49129 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49130 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49131 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49132 {
49133 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49170 }
49171 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49172 {
49173 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49189 }
49190 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49191 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49192 {
49193 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49206 }
49207 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49208 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49209 {
49210 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49217 }
49218 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49219 {
49220 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49275 }
49276
49277 // Initialize threading, some globals and such
49278 __wxPyPreStart(d);
49279
49280
49281 // Although these are defined in __version__ they need to be here too so
49282 // that an assert can be done to ensure that the wxPython and the wxWindows
49283 // versions match.
49284 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49285 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49286 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49287
49288 }
49289
wxWidgets (Impactor)