projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
CGImage Creation is always available under OS X
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_int swig_types[36]
1379 #define SWIGTYPE_p_wxSize swig_types[37]
1380 #define SWIGTYPE_p_wxDC swig_types[38]
1381 #define SWIGTYPE_p_wxPySizer swig_types[39]
1382 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1383 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1384 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1385 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1388 #define SWIGTYPE_p_wxArrayString swig_types[46]
1389 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1390 #define SWIGTYPE_p_wxToolTip swig_types[48]
1391 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1392 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1393 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1394 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1397 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1398 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1399 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1401 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1402 #define SWIGTYPE_p_long swig_types[60]
1403 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1404 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1405 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1406 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1407 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1409 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1412 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1413 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1414 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1416 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1417 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1418 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1419 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1420 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1421 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1422 #define SWIGTYPE_p_wxRect swig_types[80]
1423 #define SWIGTYPE_p_wxButton swig_types[81]
1424 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1425 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1426 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1427 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1428 #define SWIGTYPE_p_char swig_types[86]
1429 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1430 #define SWIGTYPE_p_wxImage swig_types[88]
1431 #define SWIGTYPE_p_wxFrame swig_types[89]
1432 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1434 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1435 #define SWIGTYPE_p_wxPoint swig_types[93]
1436 #define SWIGTYPE_p_wxCursor swig_types[94]
1437 #define SWIGTYPE_p_wxObject swig_types[95]
1438 #define SWIGTYPE_p_wxInputStream swig_types[96]
1439 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1440 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxDateTime swig_types[99]
1442 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1443 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1444 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1445 #define SWIGTYPE_p_unsigned_long swig_types[103]
1446 #define SWIGTYPE_p_wxWindow swig_types[104]
1447 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1448 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1449 #define SWIGTYPE_p_wxBitmap swig_types[107]
1450 #define SWIGTYPE_unsigned_int swig_types[108]
1451 #define SWIGTYPE_p_unsigned_int swig_types[109]
1452 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1453 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1454 #define SWIGTYPE_p_unsigned_char swig_types[112]
1455 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1456 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxPyApp swig_types[116]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1462 #define SWIGTYPE_p_wxQuantize swig_types[120]
1463 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1464 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1465 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1467 #define SWIGTYPE_p_wxColour swig_types[125]
1468 #define SWIGTYPE_p_wxValidator swig_types[126]
1469 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1470 static swig_type_info *swig_types[129];
1471
1472 /* -------- TYPES TABLE (END) -------- */
1473
1474
1475 /*-----------------------------------------------
1476 @(target):= _core_.so
1477 ------------------------------------------------*/
1478 #define SWIG_init init_core_
1479
1480 #define SWIG_name "_core_"
1481
1482 #include "wx/wxPython/wxPython_int.h"
1483 #include "wx/wxPython/pyclasses.h"
1484
1485
1486 #ifndef wxPyUSE_EXPORT
1487 // Helper functions for dealing with SWIG objects and such. These are
1488 // located here so they know about the SWIG types and functions declared
1489 // in the wrapper code.
1490
1491 #include <wx/hashmap.h>
1492 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1493
1494
1495 // Maintains a hashmap of className to swig_type_info pointers. Given the
1496 // name of a class either looks up the type info in the cache, or scans the
1497 // SWIG tables for it.
1498 extern PyObject* wxPyPtrTypeMap;
1499 static
1500 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1501
1502 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1503
1504 if (typeInfoCache == NULL)
1505 typeInfoCache = new wxPyTypeInfoHashMap;
1506
1507 wxString name(className);
1508 swig_type_info* swigType = (*typeInfoCache)[name];
1509
1510 if (! swigType) {
1511 // it wasn't in the cache, so look it up from SWIG
1512 name.Append(wxT(" *"));
1513 swigType = SWIG_TypeQuery(name.mb_str());
1514
1515 // if it still wasn't found, try looking for a mapped name
1516 if (!swigType) {
1517 PyObject* item;
1518 name = className;
1519
1520 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1521 (char*)(const char*)name.mbc_str())) != NULL) {
1522 name = wxString(PyString_AsString(item), *wxConvCurrent);
1523 name.Append(wxT(" *"));
1524 swigType = SWIG_TypeQuery(name.mb_str());
1525 }
1526 }
1527 if (swigType) {
1528 // and add it to the map if found
1529 (*typeInfoCache)[className] = swigType;
1530 }
1531 }
1532 return swigType;
1533 }
1534
1535
1536 // Check if a class name is a type known to SWIG
1537 bool wxPyCheckSwigType(const wxChar* className) {
1538
1539 swig_type_info* swigType = wxPyFindSwigType(className);
1540 return swigType != NULL;
1541 }
1542
1543
1544 // Given a pointer to a C++ object and a class name, construct a Python proxy
1545 // object for it.
1546 PyObject* wxPyConstructObject(void* ptr,
1547 const wxChar* className,
1548 int setThisOwn) {
1549
1550 swig_type_info* swigType = wxPyFindSwigType(className);
1551 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1552
1553 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1554 }
1555
1556
1557 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1558 // Ensures that the proxy object is of the specified (or derived) type. If
1559 // not able to perform the conversion then a Python exception is set and the
1560 // error should be handled properly in the caller. Returns True on success.
1561 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1562 const wxChar* className) {
1563
1564 swig_type_info* swigType = wxPyFindSwigType(className);
1565 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1566
1567 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1568 }
1569
1570
1571 // Make a SWIGified pointer object suitable for a .this attribute
1572 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1573
1574 PyObject* robj = NULL;
1575
1576 swig_type_info* swigType = wxPyFindSwigType(className);
1577 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1578
1579 #ifdef SWIG_COBJECT_TYPES
1580 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1581 #else
1582 {
1583 char result[1024];
1584 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1585 PyString_FromString(result) : 0;
1586 }
1587 #endif
1588
1589 return robj;
1590 }
1591
1592
1593
1594
1595 // Export a C API in a struct. Other modules will be able to load this from
1596 // the wx._core_ module and will then have safe access to these functions,
1597 // even if they are located in another shared library.
1598 static wxPyCoreAPI API = {
1599
1600 wxPyCheckSwigType,
1601 wxPyConstructObject,
1602 wxPyConvertSwigPtr,
1603 wxPyMakeSwigPtr,
1604
1605 wxPyBeginAllowThreads,
1606 wxPyEndAllowThreads,
1607 wxPyBeginBlockThreads,
1608 wxPyEndBlockThreads,
1609
1610 wxPy_ConvertList,
1611
1612 wxString_in_helper,
1613 Py2wxString,
1614 wx2PyString,
1615
1616 byte_LIST_helper,
1617 int_LIST_helper,
1618 long_LIST_helper,
1619 string_LIST_helper,
1620 wxPoint_LIST_helper,
1621 wxBitmap_LIST_helper,
1622 wxString_LIST_helper,
1623 wxAcceleratorEntry_LIST_helper,
1624
1625 wxSize_helper,
1626 wxPoint_helper,
1627 wxRealPoint_helper,
1628 wxRect_helper,
1629 wxColour_helper,
1630 wxPoint2D_helper,
1631
1632 wxPySimple_typecheck,
1633 wxColour_typecheck,
1634
1635 wxPyCBH_setCallbackInfo,
1636 wxPyCBH_findCallback,
1637 wxPyCBH_callCallback,
1638 wxPyCBH_callCallbackObj,
1639 wxPyCBH_delete,
1640
1641 wxPyMake_wxObject,
1642 wxPyMake_wxSizer,
1643 wxPyPtrTypeMap_Add,
1644 wxPy2int_seq_helper,
1645 wxPy4int_seq_helper,
1646 wxArrayString2PyList_helper,
1647 wxArrayInt2PyList_helper,
1648
1649 wxPyClientData_dtor,
1650 wxPyUserData_dtor,
1651 wxPyOORClientData_dtor,
1652
1653 wxPyCBInputStream_create,
1654 wxPyCBInputStream_copy,
1655
1656 wxPyInstance_Check,
1657 wxPySwigInstance_Check,
1658
1659 wxPyCheckForApp
1660
1661 };
1662
1663 #endif
1664
1665
1666 #if !WXWIN_COMPATIBILITY_2_4
1667 #define wxHIDE_READONLY 0
1668 #endif
1669
1670
1671 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1672 #define SWIG_From_int PyInt_FromLong
1673 /*@@*/
1674
1675
1676 #if ! wxUSE_HOTKEY
1677 enum wxHotkeyModifier
1678 {
1679 wxMOD_NONE = 0,
1680 wxMOD_ALT = 1,
1681 wxMOD_CONTROL = 2,
1682 wxMOD_SHIFT = 4,
1683 wxMOD_WIN = 8
1684 };
1685 #define wxEVT_HOTKEY 9999
1686 #endif
1687
1688 static const wxString wxPyEmptyString(wxEmptyString);
1689 static wxString wxObject_GetClassName(wxObject *self){
1690 return self->GetClassInfo()->GetClassName();
1691 }
1692 static void wxObject_Destroy(wxObject *self){
1693 delete self;
1694 }
1695
1696 #ifndef __WXMAC__
1697 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1698 #endif
1699
1700
1701 #include <limits.h>
1702
1703
1704 SWIGINTERN int
1705 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1706 const char *errmsg)
1707 {
1708 if (value < min_value) {
1709 if (errmsg) {
1710 PyErr_Format(PyExc_OverflowError,
1711 "value %ld is less than '%s' minimum %ld",
1712 value, errmsg, min_value);
1713 }
1714 return 0;
1715 } else if (value > max_value) {
1716 if (errmsg) {
1717 PyErr_Format(PyExc_OverflowError,
1718 "value %ld is greater than '%s' maximum %ld",
1719 value, errmsg, max_value);
1720 }
1721 return 0;
1722 }
1723 return 1;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsVal_long(PyObject* obj, long* val)
1729 {
1730 if (PyNumber_Check(obj)) {
1731 if (val) *val = PyInt_AsLong(obj);
1732 return 1;
1733 }
1734 else {
1735 SWIG_type_error("number", obj);
1736 }
1737 return 0;
1738 }
1739
1740
1741 #if INT_MAX != LONG_MAX
1742 SWIGINTERN int
1743 SWIG_AsVal_int(PyObject *obj, int *val)
1744 {
1745 const char* errmsg = val ? "int" : (char*)0;
1746 long v;
1747 if (SWIG_AsVal_long(obj, &v)) {
1748 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1749 if (val) *val = (int)(v);
1750 return 1;
1751 } else {
1752 return 0;
1753 }
1754 } else {
1755 PyErr_Clear();
1756 }
1757 if (val) {
1758 SWIG_type_error(errmsg, obj);
1759 }
1760 return 0;
1761 }
1762 #else
1763 SWIGINTERNSHORT int
1764 SWIG_AsVal_int(PyObject *obj, int *val)
1765 {
1766 return SWIG_AsVal_long(obj,(long*)val);
1767 }
1768 #endif
1769
1770
1771 SWIGINTERNSHORT int
1772 SWIG_As_int(PyObject* obj)
1773 {
1774 int v;
1775 if (!SWIG_AsVal_int(obj, &v)) {
1776 /*
1777 this is needed to make valgrind/purify happier.
1778 */
1779 memset((void*)&v, 0, sizeof(int));
1780 }
1781 return v;
1782 }
1783
1784
1785 SWIGINTERNSHORT int
1786 SWIG_Check_int(PyObject* obj)
1787 {
1788 return SWIG_AsVal_int(obj, (int*)0);
1789 }
1790
1791 static PyObject *wxSize_Get(wxSize *self){
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1793 PyObject* tup = PyTuple_New(2);
1794 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1795 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1796 wxPyEndBlockThreads(blocked);
1797 return tup;
1798 }
1799
1800 SWIGINTERN int
1801 SWIG_AsVal_double(PyObject *obj, double* val)
1802 {
1803 if (PyNumber_Check(obj)) {
1804 if (val) *val = PyFloat_AsDouble(obj);
1805 return 1;
1806 }
1807 else {
1808 SWIG_type_error("number", obj);
1809 }
1810 return 0;
1811 }
1812
1813
1814 SWIGINTERNSHORT double
1815 SWIG_As_double(PyObject* obj)
1816 {
1817 double v;
1818 if (!SWIG_AsVal_double(obj, &v)) {
1819 /*
1820 this is needed to make valgrind/purify happier.
1821 */
1822 memset((void*)&v, 0, sizeof(double));
1823 }
1824 return v;
1825 }
1826
1827
1828 SWIGINTERNSHORT int
1829 SWIG_Check_double(PyObject* obj)
1830 {
1831 return SWIG_AsVal_double(obj, (double*)0);
1832 }
1833
1834
1835 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1836 #define SWIG_From_double PyFloat_FromDouble
1837 /*@@*/
1838
1839 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1840 self->x = x;
1841 self->y = y;
1842 }
1843 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 PyObject* tup = PyTuple_New(2);
1846 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1847 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1848 wxPyEndBlockThreads(blocked);
1849 return tup;
1850 }
1851
1852 SWIGINTERNSHORT long
1853 SWIG_As_long(PyObject* obj)
1854 {
1855 long v;
1856 if (!SWIG_AsVal_long(obj, &v)) {
1857 /*
1858 this is needed to make valgrind/purify happier.
1859 */
1860 memset((void*)&v, 0, sizeof(long));
1861 }
1862 return v;
1863 }
1864
1865
1866 SWIGINTERNSHORT int
1867 SWIG_Check_long(PyObject* obj)
1868 {
1869 return SWIG_AsVal_long(obj, (long*)0);
1870 }
1871
1872 static void wxPoint_Set(wxPoint *self,long x,long y){
1873 self->x = x;
1874 self->y = y;
1875 }
1876 static PyObject *wxPoint_Get(wxPoint *self){
1877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1878 PyObject* tup = PyTuple_New(2);
1879 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1880 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1881 wxPyEndBlockThreads(blocked);
1882 return tup;
1883 }
1884 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1885 self->x = x;
1886 self->y = y;
1887 self->width = width;
1888 self->height = height;
1889 }
1890 static PyObject *wxRect_Get(wxRect *self){
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1892 PyObject* tup = PyTuple_New(4);
1893 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1894 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1895 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1896 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1897 wxPyEndBlockThreads(blocked);
1898 return tup;
1899 }
1900
1901 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1902 wxRegion reg1(*r1);
1903 wxRegion reg2(*r2);
1904 wxRect dest(0,0,0,0);
1905 PyObject* obj;
1906
1907 reg1.Intersect(reg2);
1908 dest = reg1.GetBox();
1909
1910 if (dest != wxRect(0,0,0,0)) {
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 wxRect* newRect = new wxRect(dest);
1913 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1914 wxPyEndBlockThreads(blocked);
1915 return obj;
1916 }
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920
1921
1922 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1923 PyObject* o2;
1924 PyObject* o3;
1925
1926 if (!target) {
1927 target = o;
1928 } else if (target == Py_None) {
1929 Py_DECREF(Py_None);
1930 target = o;
1931 } else {
1932 if (!PyTuple_Check(target)) {
1933 o2 = target;
1934 target = PyTuple_New(1);
1935 PyTuple_SetItem(target, 0, o2);
1936 }
1937 o3 = PyTuple_New(1);
1938 PyTuple_SetItem(o3, 0, o);
1939
1940 o2 = target;
1941 target = PySequence_Concat(o2, o3);
1942 Py_DECREF(o2);
1943 Py_DECREF(o3);
1944 }
1945 return target;
1946 }
1947
1948
1949 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1950 self->m_x = x;
1951 self->m_y = y;
1952 }
1953 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1954 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1955 PyObject* tup = PyTuple_New(2);
1956 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1957 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1958 wxPyEndBlockThreads(blocked);
1959 return tup;
1960 }
1961
1962 #include "wx/wxPython/pyistream.h"
1963
1964 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1965 wxInputStream* wxis = wxPyCBInputStream::create(p);
1966 if (wxis)
1967 return new wxPyInputStream(wxis);
1968 else
1969 return NULL;
1970 }
1971
1972 SWIGINTERNSHORT PyObject*
1973 SWIG_From_char(char c)
1974 {
1975 return PyString_FromStringAndSize(&c,1);
1976 }
1977
1978
1979 SWIGINTERNSHORT PyObject*
1980 SWIG_From_unsigned_SS_long(unsigned long value)
1981 {
1982 return (value > LONG_MAX) ?
1983 PyLong_FromUnsignedLong(value)
1984 : PyInt_FromLong((long)(value));
1985 }
1986
1987
1988 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1989 SWIGINTERN int
1990 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1991 {
1992 static swig_type_info* pchar_info = 0;
1993 char* vptr = 0;
1994 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1995 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1996 if (cptr) *cptr = vptr;
1997 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1998 return SWIG_OLDOBJ;
1999 } else {
2000 PyErr_Clear();
2001 if (PyString_Check(obj)) {
2002 if (cptr) {
2003 *cptr = PyString_AS_STRING(obj);
2004 if (psize) {
2005 *psize = PyString_GET_SIZE(obj) + 1;
2006 }
2007 }
2008 return SWIG_PYSTR;
2009 }
2010 }
2011 if (cptr) {
2012 SWIG_type_error("char *", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERN int
2019 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2020 {
2021 char* cptr; size_t csize;
2022 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2023 /* in C you can do:
2024
2025 char x[5] = "hello";
2026
2027 ie, assing the array using an extra '0' char.
2028 */
2029 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2030 if (csize <= size) {
2031 if (val) {
2032 if (csize) memcpy(val, cptr, csize);
2033 if (csize < size) memset(val + csize, 0, size - csize);
2034 }
2035 return 1;
2036 }
2037 }
2038 if (val) {
2039 PyErr_Format(PyExc_TypeError,
2040 "a char array of maximum size %lu is expected",
2041 (unsigned long) size);
2042 }
2043 return 0;
2044 }
2045
2046
2047 SWIGINTERN int
2048 SWIG_AsVal_char(PyObject *obj, char *val)
2049 {
2050 const char* errmsg = val ? "char" : (char*)0;
2051 long v;
2052 if (SWIG_AsVal_long(obj, &v)) {
2053 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2054 if (val) *val = (char)(v);
2055 return 1;
2056 } else {
2057 return 0;
2058 }
2059 } else {
2060 PyErr_Clear();
2061 return SWIG_AsCharArray(obj, val, 1);
2062 }
2063 }
2064
2065
2066 SWIGINTERNSHORT char
2067 SWIG_As_char(PyObject* obj)
2068 {
2069 char v;
2070 if (!SWIG_AsVal_char(obj, &v)) {
2071 /*
2072 this is needed to make valgrind/purify happier.
2073 */
2074 memset((void*)&v, 0, sizeof(char));
2075 }
2076 return v;
2077 }
2078
2079
2080 SWIGINTERNSHORT int
2081 SWIG_Check_char(PyObject* obj)
2082 {
2083 return SWIG_AsVal_char(obj, (char*)0);
2084 }
2085
2086
2087 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2088 #define SWIG_From_long PyInt_FromLong
2089 /*@@*/
2090
2091 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2092 // We use only strings for the streams, not unicode
2093 PyObject* str = PyObject_Str(obj);
2094 if (! str) {
2095 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2096 return;
2097 }
2098 self->Write(PyString_AS_STRING(str),
2099 PyString_GET_SIZE(str));
2100 Py_DECREF(str);
2101 }
2102
2103 #include "wx/wxPython/pyistream.h"
2104
2105
2106 class wxPyFileSystemHandler : public wxFileSystemHandler
2107 {
2108 public:
2109 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2110
2111 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2112 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2113 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2114 DEC_PYCALLBACK_STRING__pure(FindNext);
2115
2116 wxString GetProtocol(const wxString& location) {
2117 return wxFileSystemHandler::GetProtocol(location);
2118 }
2119
2120 wxString GetLeftLocation(const wxString& location) {
2121 return wxFileSystemHandler::GetLeftLocation(location);
2122 }
2123
2124 wxString GetAnchor(const wxString& location) {
2125 return wxFileSystemHandler::GetAnchor(location);
2126 }
2127
2128 wxString GetRightLocation(const wxString& location) {
2129 return wxFileSystemHandler::GetRightLocation(location);
2130 }
2131
2132 wxString GetMimeTypeFromExt(const wxString& location) {
2133 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2134 }
2135
2136 PYPRIVATE;
2137 };
2138
2139
2140 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2141 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2142 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2143 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2144
2145
2146 SWIGINTERN int
2147 SWIG_AsVal_bool(PyObject *obj, bool *val)
2148 {
2149 if (obj == Py_True) {
2150 if (val) *val = true;
2151 return 1;
2152 }
2153 if (obj == Py_False) {
2154 if (val) *val = false;
2155 return 1;
2156 }
2157 int res = 0;
2158 if (SWIG_AsVal_int(obj, &res)) {
2159 if (val) *val = res ? true : false;
2160 return 1;
2161 } else {
2162 PyErr_Clear();
2163 }
2164 if (val) {
2165 SWIG_type_error("bool", obj);
2166 }
2167 return 0;
2168 }
2169
2170
2171 SWIGINTERNSHORT bool
2172 SWIG_As_bool(PyObject* obj)
2173 {
2174 bool v;
2175 if (!SWIG_AsVal_bool(obj, &v)) {
2176 /*
2177 this is needed to make valgrind/purify happier.
2178 */
2179 memset((void*)&v, 0, sizeof(bool));
2180 }
2181 return v;
2182 }
2183
2184
2185 SWIGINTERNSHORT int
2186 SWIG_Check_bool(PyObject* obj)
2187 {
2188 return SWIG_AsVal_bool(obj, (bool*)0);
2189 }
2190
2191 static wxString FileSystem_URLToFileName(wxString const &url){
2192 wxFileName fname = wxFileSystem::URLToFileName(url);
2193 return fname.GetFullPath();
2194 }
2195
2196 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2197 wxImage& image,
2198 long type) {
2199 wxMemoryFSHandler::AddFile(filename, image, type);
2200 }
2201
2202 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2203 const wxBitmap& bitmap,
2204 long type) {
2205 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2206 }
2207
2208 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2209 PyObject* data) {
2210 if (! PyString_Check(data)) {
2211 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2212 "Expected string object"));
2213 return;
2214 }
2215
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 void* ptr = (void*)PyString_AsString(data);
2218 size_t size = PyString_Size(data);
2219 wxPyEndBlockThreads(blocked);
2220
2221 wxMemoryFSHandler::AddFile(filename, ptr, size);
2222 }
2223
2224
2225 #include "wx/wxPython/pyistream.h"
2226
2227
2228 SWIGINTERN int
2229 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2230 {
2231 long v = 0;
2232 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2233 SWIG_type_error("unsigned number", obj);
2234 }
2235 else if (val)
2236 *val = (unsigned long)v;
2237 return 1;
2238 }
2239
2240
2241 SWIGINTERNSHORT int
2242 SWIG_CheckUnsignedLongInRange(unsigned long value,
2243 unsigned long max_value,
2244 const char *errmsg)
2245 {
2246 if (value > max_value) {
2247 if (errmsg) {
2248 PyErr_Format(PyExc_OverflowError,
2249 "value %lu is greater than '%s' minimum %lu",
2250 value, errmsg, max_value);
2251 }
2252 return 0;
2253 }
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERN int
2259 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2260 {
2261 const char* errmsg = val ? "unsigned char" : (char*)0;
2262 unsigned long v;
2263 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2264 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2265 if (val) *val = (unsigned char)(v);
2266 return 1;
2267 } else {
2268 return 0;
2269 }
2270 } else {
2271 PyErr_Clear();
2272 }
2273 if (val) {
2274 SWIG_type_error(errmsg, obj);
2275 }
2276 return 0;
2277 }
2278
2279
2280 SWIGINTERNSHORT unsigned char
2281 SWIG_As_unsigned_SS_char(PyObject* obj)
2282 {
2283 unsigned char v;
2284 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2285 /*
2286 this is needed to make valgrind/purify happier.
2287 */
2288 memset((void*)&v, 0, sizeof(unsigned char));
2289 }
2290 return v;
2291 }
2292
2293
2294 SWIGINTERNSHORT int
2295 SWIG_Check_unsigned_SS_char(PyObject* obj)
2296 {
2297 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2298 }
2299
2300
2301 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2302 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2303 /*@@*/
2304
2305
2306
2307 SWIGINTERNSHORT unsigned long
2308 SWIG_As_unsigned_SS_long(PyObject* obj)
2309 {
2310 unsigned long v;
2311 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2312 /*
2313 this is needed to make valgrind/purify happier.
2314 */
2315 memset((void*)&v, 0, sizeof(unsigned long));
2316 }
2317 return v;
2318 }
2319
2320
2321 SWIGINTERNSHORT int
2322 SWIG_Check_unsigned_SS_long(PyObject* obj)
2323 {
2324 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2325 }
2326
2327 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2328 wxImageHistogramEntry e = (*self)[key];
2329 return e.value;
2330 }
2331 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2332 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2333 wxImageHistogramEntry e = (*self)[key];
2334 return e.value;
2335 }
2336 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2337 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2338 colour.Green(),
2339 colour.Blue());
2340 wxImageHistogramEntry e = (*self)[key];
2341 return e.value;
2342 }
2343
2344 typedef unsigned char* buffer;
2345
2346 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2347 if (width > 0 && height > 0)
2348 return new wxImage(width, height, clear);
2349 else
2350 return new wxImage;
2351 }
2352 static wxImage *new_wxImage(wxBitmap const &bitmap){
2353 return new wxImage(bitmap.ConvertToImage());
2354 }
2355 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2356 if (DATASIZE != width*height*3) {
2357 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2358 return NULL;
2359 }
2360
2361 // Copy the source data so the wxImage can clean it up later
2362 buffer copy = (buffer)malloc(DATASIZE);
2363 if (copy == NULL) {
2364 wxPyBLOCK_THREADS(PyErr_NoMemory());
2365 return NULL;
2366 }
2367 memcpy(copy, data, DATASIZE);
2368 return new wxImage(width, height, copy, false);
2369 }
2370 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2371 if (DATASIZE != width*height*3) {
2372 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2373 return NULL;
2374 }
2375 if (ALPHASIZE != width*height) {
2376 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2377 return NULL;
2378 }
2379
2380 // Copy the source data so the wxImage can clean it up later
2381 buffer dcopy = (buffer)malloc(DATASIZE);
2382 if (dcopy == NULL) {
2383 wxPyBLOCK_THREADS(PyErr_NoMemory());
2384 return NULL;
2385 }
2386 memcpy(dcopy, data, DATASIZE);
2387
2388 buffer acopy = (buffer)malloc(ALPHASIZE);
2389 if (acopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(acopy, alpha, ALPHASIZE);
2394
2395 return new wxImage(width, height, dcopy, acopy, false);
2396 }
2397 static wxSize wxImage_GetSize(wxImage *self){
2398 wxSize size(self->GetWidth(), self->GetHeight());
2399 return size;
2400 }
2401 static PyObject *wxImage_GetData(wxImage *self){
2402 buffer data = self->GetData();
2403 int len = self->GetWidth() * self->GetHeight() * 3;
2404 PyObject* rv;
2405 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2406 return rv;
2407 }
2408 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2409 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2410 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2411 return;
2412 }
2413 buffer copy = (buffer)malloc(DATASIZE);
2414 if (copy == NULL) {
2415 wxPyBLOCK_THREADS(PyErr_NoMemory());
2416 return;
2417 }
2418 memcpy(copy, data, DATASIZE);
2419 self->SetData(copy, false);
2420 // wxImage takes ownership of copy...
2421 }
2422 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2423 buffer data = self->GetData();
2424 int len = self->GetWidth() * self->GetHeight() * 3;
2425 PyObject* rv;
2426 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2427 return rv;
2428 }
2429 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2430 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2431 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2432 return;
2433 }
2434 self->SetData(data, true);
2435 }
2436 static PyObject *wxImage_GetAlphaData(wxImage *self){
2437 buffer data = self->GetAlpha();
2438 if (! data) {
2439 RETURN_NONE();
2440 } else {
2441 int len = self->GetWidth() * self->GetHeight();
2442 PyObject* rv;
2443 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2444 return rv;
2445 }
2446 }
2447 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2448 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2449 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2450 return;
2451 }
2452 buffer acopy = (buffer)malloc(ALPHASIZE);
2453 if (acopy == NULL) {
2454 wxPyBLOCK_THREADS(PyErr_NoMemory());
2455 return;
2456 }
2457 memcpy(acopy, alpha, ALPHASIZE);
2458 self->SetAlpha(acopy, false);
2459 // wxImage takes ownership of acopy...
2460 }
2461 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2462 buffer data = self->GetAlpha();
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2466 return rv;
2467 }
2468 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2469 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2470 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2471 return;
2472 }
2473 self->SetAlpha(alpha, true);
2474 }
2475 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2476 wxBitmap bitmap(*self, depth);
2477 return bitmap;
2478 }
2479 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2480 wxImage mono = self->ConvertToMono( red, green, blue );
2481 wxBitmap bitmap( mono, 1 );
2482 return bitmap;
2483 }
2484 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2485 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2487 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2491 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2492 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2493 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2494 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2495 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2496 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2497 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2498 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2499
2500 #include <wx/quantize.h>
2501
2502 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2503 return wxQuantize::Quantize(src, dest,
2504 //NULL, // palette
2505 desiredNoColours,
2506 NULL, // eightBitData
2507 flags);
2508 }
2509 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2510 if (PyCallable_Check(func)) {
2511 self->Connect(id, lastId, eventType,
2512 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2513 new wxPyCallback(func));
2514 }
2515 else if (func == Py_None) {
2516 self->Disconnect(id, lastId, eventType,
2517 (wxObjectEventFunction)
2518 &wxPyCallback::EventThunker);
2519 }
2520 else {
2521 wxPyBLOCK_THREADS(
2522 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2523 }
2524 }
2525 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2526 return self->Disconnect(id, lastId, eventType,
2527 (wxObjectEventFunction)
2528 &wxPyCallback::EventThunker);
2529 }
2530 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2531 if (_self && _self != Py_None) {
2532 self->SetClientObject(new wxPyOORClientData(_self, incref));
2533 }
2534 else {
2535 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2536 if (data) {
2537 self->SetClientObject(NULL); // This will delete it too
2538 }
2539 }
2540 }
2541
2542 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2543 #if wxUSE_UNICODE
2544 return self->GetUnicodeKey();
2545 #else
2546 return 0;
2547 #endif
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560
2561 #if UINT_MAX != ULONG_MAX
2562 SWIGINTERN int
2563 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2564 {
2565 const char* errmsg = val ? "unsigned int" : (char*)0;
2566 unsigned long v;
2567 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2568 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2569 if (val) *val = (unsigned int)(v);
2570 return 1;
2571 }
2572 } else {
2573 PyErr_Clear();
2574 }
2575 if (val) {
2576 SWIG_type_error(errmsg, obj);
2577 }
2578 return 0;
2579 }
2580 #else
2581 SWIGINTERNSHORT unsigned int
2582 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2583 {
2584 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2585 }
2586 #endif
2587
2588
2589 SWIGINTERNSHORT unsigned int
2590 SWIG_As_unsigned_SS_int(PyObject* obj)
2591 {
2592 unsigned int v;
2593 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2594 /*
2595 this is needed to make valgrind/purify happier.
2596 */
2597 memset((void*)&v, 0, sizeof(unsigned int));
2598 }
2599 return v;
2600 }
2601
2602
2603 SWIGINTERNSHORT int
2604 SWIG_Check_unsigned_SS_int(PyObject* obj)
2605 {
2606 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2607 }
2608
2609 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2610 self->m_size = size;
2611 }
2612 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2613 int count = self->GetNumberOfFiles();
2614 wxString* files = self->GetFiles();
2615 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2616 PyObject* list = PyList_New(count);
2617
2618 if (!list) {
2619 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2620 wxPyEndBlockThreads(blocked);
2621 return NULL;
2622 }
2623
2624 for (int i=0; i<count; i++) {
2625 PyList_SetItem(list, i, wx2PyString(files[i]));
2626 }
2627 wxPyEndBlockThreads(blocked);
2628 return list;
2629 }
2630
2631
2632 static wxPyApp *new_wxPyApp(){
2633 wxPythonApp = new wxPyApp();
2634 return wxPythonApp;
2635 }
2636 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2637
2638 void wxApp_CleanUp() {
2639 __wxPyCleanup();
2640 }
2641
2642
2643 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2644
2645
2646 SWIGINTERNSHORT int
2647 SWIG_AsCharPtr(PyObject *obj, char **val)
2648 {
2649 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2650 return 1;
2651 }
2652 if (val) {
2653 PyErr_Clear();
2654 SWIG_type_error("char *", obj);
2655 }
2656 return 0;
2657 }
2658
2659
2660 SWIGINTERN PyObject *
2661 SWIG_FromCharPtr(const char* cptr)
2662 {
2663 if (cptr) {
2664 size_t size = strlen(cptr);
2665 if (size > INT_MAX) {
2666 return SWIG_NewPointerObj((char*)(cptr),
2667 SWIG_TypeQuery("char *"), 0);
2668 } else {
2669 if (size != 0) {
2670 return PyString_FromStringAndSize(cptr, size);
2671 } else {
2672 return PyString_FromString(cptr);
2673 }
2674 }
2675 }
2676 Py_INCREF(Py_None);
2677 return Py_None;
2678 }
2679
2680
2681 #ifdef __WXMAC__
2682
2683 // A dummy class that raises an exception if used...
2684 class wxEventLoop
2685 {
2686 public:
2687 wxEventLoop() { wxPyRaiseNotImplemented(); }
2688 int Run() { return 0; }
2689 void Exit(int rc = 0) {}
2690 bool Pending() const { return false; }
2691 bool Dispatch() { return false; }
2692 bool IsRunning() const { return false; }
2693 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2694 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2695 };
2696
2697 #else
2698
2699 #include <wx/evtloop.h>
2700
2701 #endif
2702
2703
2704
2705 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2706 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2707 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2708 static PyObject *wxWindow_GetChildren(wxWindow *self){
2709 wxWindowList& list = self->GetChildren();
2710 return wxPy_ConvertList(&list);
2711 }
2712 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2713 #if wxUSE_HOTKEY
2714 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2715 #else
2716 return false;
2717 #endif
2718 }
2719 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2720
2721
2722
2723 return false;
2724
2725 }
2726 static long wxWindow_GetHandle(wxWindow *self){
2727 return wxPyGetWinHandle(self);
2728 }
2729 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2730 self->AssociateHandle((WXWidget)handle);
2731 }
2732 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2733
2734 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowById(id, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByName( const wxString& name,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByName(name, parent);
2741 }
2742
2743 wxWindow* wxFindWindowByLabel( const wxString& label,
2744 const wxWindow *parent = NULL ) {
2745 return wxWindow::FindWindowByLabel(label, parent);
2746 }
2747
2748
2749 #ifdef __WXMSW__
2750 #include <wx/msw/private.h> // to get wxGetWindowId
2751 #endif
2752
2753
2754 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2755 #ifdef __WXMSW__
2756 WXHWND hWnd = (WXHWND)_hWnd;
2757 long id = wxGetWindowId(hWnd);
2758 wxWindow* win = new wxWindow;
2759 parent->AddChild(win);
2760 win->SetEventHandler(win);
2761 win->SetHWND(hWnd);
2762 win->SetId(id);
2763 win->SubclassWin(hWnd);
2764 win->AdoptAttributesFromHWND();
2765 win->SetupColours();
2766 return win;
2767 #else
2768 wxPyRaiseNotImplemented();
2769 return NULL;
2770 #endif
2771 }
2772
2773
2774 PyObject* GetTopLevelWindows() {
2775 return wxPy_ConvertList(&wxTopLevelWindows);
2776 }
2777
2778
2779 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2780 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2781 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2782
2783 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2784
2785 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2786 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2787 wxMenuItemList& list = self->GetMenuItems();
2788 return wxPy_ConvertList(&list);
2789 }
2790 static void MenuBar_SetAutoWindowMenu(bool enable){}
2791 static bool MenuBar_GetAutoWindowMenu(){ return false; }
2792 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2793 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2794 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2795 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2796 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2797 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2798 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2799 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2800 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2801 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2802 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2803 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2804 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2805 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2806 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2807 static const wxString wxPyControlNameStr(wxControlNameStr);
2808 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2809 if (clientData) {
2810 wxPyClientData* data = new wxPyClientData(clientData);
2811 return self->Append(item, data);
2812 } else
2813 return self->Append(item);
2814 }
2815 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2816 if (clientData) {
2817 wxPyClientData* data = new wxPyClientData(clientData);
2818 return self->Insert(item, pos, data);
2819 } else
2820 return self->Insert(item, pos);
2821 }
2822 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2823 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2824 if (data) {
2825 Py_INCREF(data->m_obj);
2826 return data->m_obj;
2827 } else {
2828 Py_INCREF(Py_None);
2829 return Py_None;
2830 }
2831 }
2832 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2833 wxPyClientData* data = new wxPyClientData(clientData);
2834 self->SetClientObject(n, data);
2835 }
2836
2837
2838 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2839 wxPyUserData* data = NULL;
2840 if ( userData ) {
2841 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2842 data = new wxPyUserData(userData);
2843 wxPyEndBlockThreads(blocked);
2844 }
2845 return new wxSizerItem(window, proportion, flag, border, data);
2846 }
2847 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2848 wxPyUserData* data = NULL;
2849 if ( userData ) {
2850 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2851 data = new wxPyUserData(userData);
2852 wxPyEndBlockThreads(blocked);
2853 }
2854 return new wxSizerItem(width, height, proportion, flag, border, data);
2855 }
2856 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2857 wxPyUserData* data = NULL;
2858 if ( userData ) {
2859 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2860 data = new wxPyUserData(userData);
2861 wxPyEndBlockThreads(blocked);
2862 }
2863 return new wxSizerItem(sizer, proportion, flag, border, data);
2864 }
2865
2866 #include <float.h>
2867 SWIGINTERN int
2868 SWIG_CheckDoubleInRange(double value, double min_value,
2869 double max_value, const char* errmsg)
2870 {
2871 if (value < min_value) {
2872 if (errmsg) {
2873 PyErr_Format(PyExc_OverflowError,
2874 "value %g is less than %s minimum %g",
2875 value, errmsg, min_value);
2876 }
2877 return 0;
2878 } else if (value > max_value) {
2879 if (errmsg) {
2880 PyErr_Format(PyExc_OverflowError,
2881 "value %g is greater than %s maximum %g",
2882 value, errmsg, max_value);
2883 }
2884 return 0;
2885 }
2886 return 1;
2887 }
2888
2889
2890 SWIGINTERN int
2891 SWIG_AsVal_float(PyObject *obj, float *val)
2892 {
2893 const char* errmsg = val ? "float" : (char*)0;
2894 double v;
2895 if (SWIG_AsVal_double(obj, &v)) {
2896 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2897 if (val) *val = (float)(v);
2898 return 1;
2899 } else {
2900 return 0;
2901 }
2902 } else {
2903 PyErr_Clear();
2904 }
2905 if (val) {
2906 SWIG_type_error(errmsg, obj);
2907 }
2908 return 0;
2909 }
2910
2911
2912 SWIGINTERNSHORT float
2913 SWIG_As_float(PyObject* obj)
2914 {
2915 float v;
2916 if (!SWIG_AsVal_float(obj, &v)) {
2917 /*
2918 this is needed to make valgrind/purify happier.
2919 */
2920 memset((void*)&v, 0, sizeof(float));
2921 }
2922 return v;
2923 }
2924
2925
2926 SWIGINTERNSHORT int
2927 SWIG_Check_float(PyObject* obj)
2928 {
2929 return SWIG_AsVal_float(obj, (float*)0);
2930 }
2931
2932
2933 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2934 #define SWIG_From_float PyFloat_FromDouble
2935 /*@@*/
2936
2937 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2938 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2939 if (data) {
2940 Py_INCREF(data->m_obj);
2941 return data->m_obj;
2942 } else {
2943 Py_INCREF(Py_None);
2944 return Py_None;
2945 }
2946 }
2947
2948 // Figure out the type of the sizer item
2949
2950 struct wxPySizerItemInfo {
2951 wxPySizerItemInfo()
2952 : window(NULL), sizer(NULL), gotSize(false),
2953 size(wxDefaultSize), gotPos(false), pos(-1)
2954 {}
2955
2956 wxWindow* window;
2957 wxSizer* sizer;
2958 bool gotSize;
2959 wxSize size;
2960 bool gotPos;
2961 int pos;
2962 };
2963
2964 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2965
2966 wxPySizerItemInfo info;
2967 wxSize size;
2968 wxSize* sizePtr = &size;
2969
2970 // Find out what the type of the item is
2971 // try wxWindow
2972 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2973 PyErr_Clear();
2974 info.window = NULL;
2975
2976 // try wxSizer
2977 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2978 PyErr_Clear();
2979 info.sizer = NULL;
2980
2981 // try wxSize or (w,h)
2982 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2983 info.size = *sizePtr;
2984 info.gotSize = true;
2985 }
2986
2987 // or a single int
2988 if (checkIdx && PyInt_Check(item)) {
2989 info.pos = PyInt_AsLong(item);
2990 info.gotPos = true;
2991 }
2992 }
2993 }
2994
2995 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2996 // no expected type, figure out what kind of error message to generate
2997 if ( !checkSize && !checkIdx )
2998 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2999 else if ( checkSize && !checkIdx )
3000 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
3001 else if ( !checkSize && checkIdx)
3002 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
3003 else
3004 // can this one happen?
3005 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
3006 }
3007
3008 return info;
3009 }
3010
3011 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3012 if (!self->GetClientObject())
3013 self->SetClientObject(new wxPyOORClientData(_self));
3014 }
3015 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3016
3017 wxPyUserData* data = NULL;
3018 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3019 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3020 if ( userData && (info.window || info.sizer || info.gotSize) )
3021 data = new wxPyUserData(userData);
3022 wxPyEndBlockThreads(blocked);
3023
3024 // Now call the real Add method if a valid item type was found
3025 if ( info.window )
3026 return self->Add(info.window, proportion, flag, border, data);
3027 else if ( info.sizer )
3028 return self->Add(info.sizer, proportion, flag, border, data);
3029 else if (info.gotSize)
3030 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3031 proportion, flag, border, data);
3032 else
3033 return NULL;
3034 }
3035 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3036
3037 wxPyUserData* data = NULL;
3038 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3039 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3040 if ( userData && (info.window || info.sizer || info.gotSize) )
3041 data = new wxPyUserData(userData);
3042 wxPyEndBlockThreads(blocked);
3043
3044 // Now call the real Insert method if a valid item type was found
3045 if ( info.window )
3046 return self->Insert(before, info.window, proportion, flag, border, data);
3047 else if ( info.sizer )
3048 return self->Insert(before, info.sizer, proportion, flag, border, data);
3049 else if (info.gotSize)
3050 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3051 proportion, flag, border, data);
3052 else
3053 return NULL;
3054 }
3055 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3056
3057 wxPyUserData* data = NULL;
3058 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3059 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3060 if ( userData && (info.window || info.sizer || info.gotSize) )
3061 data = new wxPyUserData(userData);
3062 wxPyEndBlockThreads(blocked);
3063
3064 // Now call the real Prepend method if a valid item type was found
3065 if ( info.window )
3066 return self->Prepend(info.window, proportion, flag, border, data);
3067 else if ( info.sizer )
3068 return self->Prepend(info.sizer, proportion, flag, border, data);
3069 else if (info.gotSize)
3070 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3071 proportion, flag, border, data);
3072 else
3073 return NULL;
3074 }
3075 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3078 wxPyEndBlockThreads(blocked);
3079 if ( info.window )
3080 return self->Remove(info.window);
3081 else if ( info.sizer )
3082 return self->Remove(info.sizer);
3083 else if ( info.gotPos )
3084 return self->Remove(info.pos);
3085 else
3086 return false;
3087 }
3088 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3089 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3090 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3091 wxPyEndBlockThreads(blocked);
3092 if ( info.window )
3093 return self->Detach(info.window);
3094 else if ( info.sizer )
3095 return self->Detach(info.sizer);
3096 else if ( info.gotPos )
3097 return self->Detach(info.pos);
3098 else
3099 return false;
3100 }
3101 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3103 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3104 wxPyEndBlockThreads(blocked);
3105 if ( info.window )
3106 return self->GetItem(info.window);
3107 else if ( info.sizer )
3108 return self->GetItem(info.sizer);
3109 else if ( info.gotPos )
3110 return self->GetItem(info.pos);
3111 else
3112 return NULL;
3113 }
3114 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3115 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3117 wxPyEndBlockThreads(blocked);
3118 if ( info.window )
3119 self->SetItemMinSize(info.window, size);
3120 else if ( info.sizer )
3121 self->SetItemMinSize(info.sizer, size);
3122 else if ( info.gotPos )
3123 self->SetItemMinSize(info.pos, size);
3124 }
3125 static PyObject *wxSizer_GetChildren(wxSizer *self){
3126 wxSizerItemList& list = self->GetChildren();
3127 return wxPy_ConvertList(&list);
3128 }
3129 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3132 wxPyEndBlockThreads(blocked);
3133 if ( info.window )
3134 return self->Show(info.window, show, recursive);
3135 else if ( info.sizer )
3136 return self->Show(info.sizer, show, recursive);
3137 else if ( info.gotPos )
3138 return self->Show(info.pos, show);
3139 else
3140 return false;
3141 }
3142 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3143 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3144 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3145 wxPyEndBlockThreads(blocked);
3146 if ( info.window )
3147 return self->IsShown(info.window);
3148 else if ( info.sizer )
3149 return self->IsShown(info.sizer);
3150 else if ( info.gotPos )
3151 return self->IsShown(info.pos);
3152 else
3153 return false;
3154 }
3155
3156 // See pyclasses.h
3157 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3158 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3159 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3160
3161
3162
3163
3164 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3165 {
3166 if (source == Py_None) {
3167 **obj = wxGBPosition(-1,-1);
3168 return true;
3169 }
3170 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3171 }
3172
3173 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3174 {
3175 if (source == Py_None) {
3176 **obj = wxGBSpan(-1,-1);
3177 return true;
3178 }
3179 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3180 }
3181
3182
3183 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3184 self->SetRow(row);
3185 self->SetCol(col);
3186 }
3187 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3189 PyObject* tup = PyTuple_New(2);
3190 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3191 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3192 wxPyEndBlockThreads(blocked);
3193 return tup;
3194 }
3195 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3196 self->SetRowspan(rowspan);
3197 self->SetColspan(colspan);
3198 }
3199 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(2);
3202 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3203 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3204 wxPyEndBlockThreads(blocked);
3205 return tup;
3206 }
3207 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3208 wxPyUserData* data = NULL;
3209 if ( userData ) {
3210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3211 data = new wxPyUserData(userData);
3212 wxPyEndBlockThreads(blocked);
3213 }
3214 return new wxGBSizerItem(window, pos, span, flag, border, data);
3215 }
3216 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3217 wxPyUserData* data = NULL;
3218 if ( userData ) {
3219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3220 data = new wxPyUserData(userData);
3221 wxPyEndBlockThreads(blocked);
3222 }
3223 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3224 }
3225 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3226 wxPyUserData* data = NULL;
3227 if ( userData ) {
3228 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3229 data = new wxPyUserData(userData);
3230 wxPyEndBlockThreads(blocked);
3231 }
3232 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3233 }
3234 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3235 int row, col;
3236 self->GetEndPos(row, col);
3237 return wxGBPosition(row, col);
3238 }
3239 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3240
3241 wxPyUserData* data = NULL;
3242 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3243 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3244 if ( userData && (info.window || info.sizer || info.gotSize) )
3245 data = new wxPyUserData(userData);
3246 wxPyEndBlockThreads(blocked);
3247
3248 // Now call the real Add method if a valid item type was found
3249 if ( info.window )
3250 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3251 else if ( info.sizer )
3252 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3253 else if (info.gotSize)
3254 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3255 pos, span, flag, border, data);
3256 return NULL;
3257 }
3258
3259
3260 #ifdef __cplusplus
3261 extern "C" {
3262 #endif
3263 static int _wrap_EmptyString_set(PyObject *) {
3264 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3265 return 1;
3266 }
3267
3268
3269 static PyObject *_wrap_EmptyString_get(void) {
3270 PyObject *pyobj;
3271
3272 {
3273 #if wxUSE_UNICODE
3274 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3275 #else
3276 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3277 #endif
3278 }
3279 return pyobj;
3280 }
3281
3282
3283 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3284 PyObject *resultobj;
3285 wxObject *arg1 = (wxObject *) 0 ;
3286 wxString result;
3287 PyObject * obj0 = 0 ;
3288 char *kwnames[] = {
3289 (char *) "self", NULL
3290 };
3291
3292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3294 if (SWIG_arg_fail(1)) SWIG_fail;
3295 {
3296 PyThreadState* __tstate = wxPyBeginAllowThreads();
3297 result = wxObject_GetClassName(arg1);
3298
3299 wxPyEndAllowThreads(__tstate);
3300 if (PyErr_Occurred()) SWIG_fail;
3301 }
3302 {
3303 #if wxUSE_UNICODE
3304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3305 #else
3306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3307 #endif
3308 }
3309 return resultobj;
3310 fail:
3311 return NULL;
3312 }
3313
3314
3315 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3316 PyObject *resultobj;
3317 wxObject *arg1 = (wxObject *) 0 ;
3318 PyObject * obj0 = 0 ;
3319 char *kwnames[] = {
3320 (char *) "self", NULL
3321 };
3322
3323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3325 if (SWIG_arg_fail(1)) SWIG_fail;
3326 {
3327 PyThreadState* __tstate = wxPyBeginAllowThreads();
3328 wxObject_Destroy(arg1);
3329
3330 wxPyEndAllowThreads(__tstate);
3331 if (PyErr_Occurred()) SWIG_fail;
3332 }
3333 Py_INCREF(Py_None); resultobj = Py_None;
3334 return resultobj;
3335 fail:
3336 return NULL;
3337 }
3338
3339
3340 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3341 PyObject *obj;
3342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3343 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3344 Py_INCREF(obj);
3345 return Py_BuildValue((char *)"");
3346 }
3347 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3348 PyObject *resultobj;
3349 wxSize *arg1 = (wxSize *) 0 ;
3350 int arg2 ;
3351 PyObject * obj0 = 0 ;
3352 PyObject * obj1 = 0 ;
3353 char *kwnames[] = {
3354 (char *) "self",(char *) "x", NULL
3355 };
3356
3357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3359 if (SWIG_arg_fail(1)) SWIG_fail;
3360 {
3361 arg2 = (int)(SWIG_As_int(obj1));
3362 if (SWIG_arg_fail(2)) SWIG_fail;
3363 }
3364 if (arg1) (arg1)->x = arg2;
3365
3366 Py_INCREF(Py_None); resultobj = Py_None;
3367 return resultobj;
3368 fail:
3369 return NULL;
3370 }
3371
3372
3373 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3374 PyObject *resultobj;
3375 wxSize *arg1 = (wxSize *) 0 ;
3376 int result;
3377 PyObject * obj0 = 0 ;
3378 char *kwnames[] = {
3379 (char *) "self", NULL
3380 };
3381
3382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3384 if (SWIG_arg_fail(1)) SWIG_fail;
3385 result = (int) ((arg1)->x);
3386
3387 {
3388 resultobj = SWIG_From_int((int)(result));
3389 }
3390 return resultobj;
3391 fail:
3392 return NULL;
3393 }
3394
3395
3396 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3397 PyObject *resultobj;
3398 wxSize *arg1 = (wxSize *) 0 ;
3399 int arg2 ;
3400 PyObject * obj0 = 0 ;
3401 PyObject * obj1 = 0 ;
3402 char *kwnames[] = {
3403 (char *) "self",(char *) "y", NULL
3404 };
3405
3406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3408 if (SWIG_arg_fail(1)) SWIG_fail;
3409 {
3410 arg2 = (int)(SWIG_As_int(obj1));
3411 if (SWIG_arg_fail(2)) SWIG_fail;
3412 }
3413 if (arg1) (arg1)->y = arg2;
3414
3415 Py_INCREF(Py_None); resultobj = Py_None;
3416 return resultobj;
3417 fail:
3418 return NULL;
3419 }
3420
3421
3422 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3423 PyObject *resultobj;
3424 wxSize *arg1 = (wxSize *) 0 ;
3425 int result;
3426 PyObject * obj0 = 0 ;
3427 char *kwnames[] = {
3428 (char *) "self", NULL
3429 };
3430
3431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3433 if (SWIG_arg_fail(1)) SWIG_fail;
3434 result = (int) ((arg1)->y);
3435
3436 {
3437 resultobj = SWIG_From_int((int)(result));
3438 }
3439 return resultobj;
3440 fail:
3441 return NULL;
3442 }
3443
3444
3445 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3446 PyObject *resultobj;
3447 int arg1 = (int) 0 ;
3448 int arg2 = (int) 0 ;
3449 wxSize *result;
3450 PyObject * obj0 = 0 ;
3451 PyObject * obj1 = 0 ;
3452 char *kwnames[] = {
3453 (char *) "w",(char *) "h", NULL
3454 };
3455
3456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3457 if (obj0) {
3458 {
3459 arg1 = (int)(SWIG_As_int(obj0));
3460 if (SWIG_arg_fail(1)) SWIG_fail;
3461 }
3462 }
3463 if (obj1) {
3464 {
3465 arg2 = (int)(SWIG_As_int(obj1));
3466 if (SWIG_arg_fail(2)) SWIG_fail;
3467 }
3468 }
3469 {
3470 PyThreadState* __tstate = wxPyBeginAllowThreads();
3471 result = (wxSize *)new wxSize(arg1,arg2);
3472
3473 wxPyEndAllowThreads(__tstate);
3474 if (PyErr_Occurred()) SWIG_fail;
3475 }
3476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3477 return resultobj;
3478 fail:
3479 return NULL;
3480 }
3481
3482
3483 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3484 PyObject *resultobj;
3485 wxSize *arg1 = (wxSize *) 0 ;
3486 PyObject * obj0 = 0 ;
3487 char *kwnames[] = {
3488 (char *) "self", NULL
3489 };
3490
3491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3493 if (SWIG_arg_fail(1)) SWIG_fail;
3494 {
3495 PyThreadState* __tstate = wxPyBeginAllowThreads();
3496 delete arg1;
3497
3498 wxPyEndAllowThreads(__tstate);
3499 if (PyErr_Occurred()) SWIG_fail;
3500 }
3501 Py_INCREF(Py_None); resultobj = Py_None;
3502 return resultobj;
3503 fail:
3504 return NULL;
3505 }
3506
3507
3508 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3509 PyObject *resultobj;
3510 wxSize *arg1 = (wxSize *) 0 ;
3511 wxSize *arg2 = 0 ;
3512 bool result;
3513 wxSize temp2 ;
3514 PyObject * obj0 = 0 ;
3515 PyObject * obj1 = 0 ;
3516 char *kwnames[] = {
3517 (char *) "self",(char *) "sz", NULL
3518 };
3519
3520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3522 if (SWIG_arg_fail(1)) SWIG_fail;
3523 {
3524 arg2 = &temp2;
3525 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3526 }
3527 {
3528 PyThreadState* __tstate = wxPyBeginAllowThreads();
3529 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3530
3531 wxPyEndAllowThreads(__tstate);
3532 if (PyErr_Occurred()) SWIG_fail;
3533 }
3534 {
3535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3536 }
3537 return resultobj;
3538 fail:
3539 return NULL;
3540 }
3541
3542
3543 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3544 PyObject *resultobj;
3545 wxSize *arg1 = (wxSize *) 0 ;
3546 wxSize *arg2 = 0 ;
3547 bool result;
3548 wxSize temp2 ;
3549 PyObject * obj0 = 0 ;
3550 PyObject * obj1 = 0 ;
3551 char *kwnames[] = {
3552 (char *) "self",(char *) "sz", NULL
3553 };
3554
3555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3557 if (SWIG_arg_fail(1)) SWIG_fail;
3558 {
3559 arg2 = &temp2;
3560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3561 }
3562 {
3563 PyThreadState* __tstate = wxPyBeginAllowThreads();
3564 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3565
3566 wxPyEndAllowThreads(__tstate);
3567 if (PyErr_Occurred()) SWIG_fail;
3568 }
3569 {
3570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3571 }
3572 return resultobj;
3573 fail:
3574 return NULL;
3575 }
3576
3577
3578 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3579 PyObject *resultobj;
3580 wxSize *arg1 = (wxSize *) 0 ;
3581 wxSize *arg2 = 0 ;
3582 wxSize result;
3583 wxSize temp2 ;
3584 PyObject * obj0 = 0 ;
3585 PyObject * obj1 = 0 ;
3586 char *kwnames[] = {
3587 (char *) "self",(char *) "sz", NULL
3588 };
3589
3590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3592 if (SWIG_arg_fail(1)) SWIG_fail;
3593 {
3594 arg2 = &temp2;
3595 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3596 }
3597 {
3598 PyThreadState* __tstate = wxPyBeginAllowThreads();
3599 result = (arg1)->operator +((wxSize const &)*arg2);
3600
3601 wxPyEndAllowThreads(__tstate);
3602 if (PyErr_Occurred()) SWIG_fail;
3603 }
3604 {
3605 wxSize * resultptr;
3606 resultptr = new wxSize((wxSize &)(result));
3607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3608 }
3609 return resultobj;
3610 fail:
3611 return NULL;
3612 }
3613
3614
3615 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3616 PyObject *resultobj;
3617 wxSize *arg1 = (wxSize *) 0 ;
3618 wxSize *arg2 = 0 ;
3619 wxSize result;
3620 wxSize temp2 ;
3621 PyObject * obj0 = 0 ;
3622 PyObject * obj1 = 0 ;
3623 char *kwnames[] = {
3624 (char *) "self",(char *) "sz", NULL
3625 };
3626
3627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3629 if (SWIG_arg_fail(1)) SWIG_fail;
3630 {
3631 arg2 = &temp2;
3632 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3633 }
3634 {
3635 PyThreadState* __tstate = wxPyBeginAllowThreads();
3636 result = (arg1)->operator -((wxSize const &)*arg2);
3637
3638 wxPyEndAllowThreads(__tstate);
3639 if (PyErr_Occurred()) SWIG_fail;
3640 }
3641 {
3642 wxSize * resultptr;
3643 resultptr = new wxSize((wxSize &)(result));
3644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3645 }
3646 return resultobj;
3647 fail:
3648 return NULL;
3649 }
3650
3651
3652 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3653 PyObject *resultobj;
3654 wxSize *arg1 = (wxSize *) 0 ;
3655 wxSize *arg2 = 0 ;
3656 wxSize temp2 ;
3657 PyObject * obj0 = 0 ;
3658 PyObject * obj1 = 0 ;
3659 char *kwnames[] = {
3660 (char *) "self",(char *) "sz", NULL
3661 };
3662
3663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3665 if (SWIG_arg_fail(1)) SWIG_fail;
3666 {
3667 arg2 = &temp2;
3668 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3669 }
3670 {
3671 PyThreadState* __tstate = wxPyBeginAllowThreads();
3672 (arg1)->IncTo((wxSize const &)*arg2);
3673
3674 wxPyEndAllowThreads(__tstate);
3675 if (PyErr_Occurred()) SWIG_fail;
3676 }
3677 Py_INCREF(Py_None); resultobj = Py_None;
3678 return resultobj;
3679 fail:
3680 return NULL;
3681 }
3682
3683
3684 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3685 PyObject *resultobj;
3686 wxSize *arg1 = (wxSize *) 0 ;
3687 wxSize *arg2 = 0 ;
3688 wxSize temp2 ;
3689 PyObject * obj0 = 0 ;
3690 PyObject * obj1 = 0 ;
3691 char *kwnames[] = {
3692 (char *) "self",(char *) "sz", NULL
3693 };
3694
3695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3697 if (SWIG_arg_fail(1)) SWIG_fail;
3698 {
3699 arg2 = &temp2;
3700 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3701 }
3702 {
3703 PyThreadState* __tstate = wxPyBeginAllowThreads();
3704 (arg1)->DecTo((wxSize const &)*arg2);
3705
3706 wxPyEndAllowThreads(__tstate);
3707 if (PyErr_Occurred()) SWIG_fail;
3708 }
3709 Py_INCREF(Py_None); resultobj = Py_None;
3710 return resultobj;
3711 fail:
3712 return NULL;
3713 }
3714
3715
3716 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3717 PyObject *resultobj;
3718 wxSize *arg1 = (wxSize *) 0 ;
3719 int arg2 ;
3720 int arg3 ;
3721 PyObject * obj0 = 0 ;
3722 PyObject * obj1 = 0 ;
3723 PyObject * obj2 = 0 ;
3724 char *kwnames[] = {
3725 (char *) "self",(char *) "w",(char *) "h", NULL
3726 };
3727
3728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3730 if (SWIG_arg_fail(1)) SWIG_fail;
3731 {
3732 arg2 = (int)(SWIG_As_int(obj1));
3733 if (SWIG_arg_fail(2)) SWIG_fail;
3734 }
3735 {
3736 arg3 = (int)(SWIG_As_int(obj2));
3737 if (SWIG_arg_fail(3)) SWIG_fail;
3738 }
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 (arg1)->Set(arg2,arg3);
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 Py_INCREF(Py_None); resultobj = Py_None;
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj;
3755 wxSize *arg1 = (wxSize *) 0 ;
3756 int arg2 ;
3757 PyObject * obj0 = 0 ;
3758 PyObject * obj1 = 0 ;
3759 char *kwnames[] = {
3760 (char *) "self",(char *) "w", NULL
3761 };
3762
3763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3765 if (SWIG_arg_fail(1)) SWIG_fail;
3766 {
3767 arg2 = (int)(SWIG_As_int(obj1));
3768 if (SWIG_arg_fail(2)) SWIG_fail;
3769 }
3770 {
3771 PyThreadState* __tstate = wxPyBeginAllowThreads();
3772 (arg1)->SetWidth(arg2);
3773
3774 wxPyEndAllowThreads(__tstate);
3775 if (PyErr_Occurred()) SWIG_fail;
3776 }
3777 Py_INCREF(Py_None); resultobj = Py_None;
3778 return resultobj;
3779 fail:
3780 return NULL;
3781 }
3782
3783
3784 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3785 PyObject *resultobj;
3786 wxSize *arg1 = (wxSize *) 0 ;
3787 int arg2 ;
3788 PyObject * obj0 = 0 ;
3789 PyObject * obj1 = 0 ;
3790 char *kwnames[] = {
3791 (char *) "self",(char *) "h", NULL
3792 };
3793
3794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3796 if (SWIG_arg_fail(1)) SWIG_fail;
3797 {
3798 arg2 = (int)(SWIG_As_int(obj1));
3799 if (SWIG_arg_fail(2)) SWIG_fail;
3800 }
3801 {
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 (arg1)->SetHeight(arg2);
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 Py_INCREF(Py_None); resultobj = Py_None;
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj;
3817 wxSize *arg1 = (wxSize *) 0 ;
3818 int result;
3819 PyObject * obj0 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "self", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3826 if (SWIG_arg_fail(1)) SWIG_fail;
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (int)((wxSize const *)arg1)->GetWidth();
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = SWIG_From_int((int)(result));
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxSize *arg1 = (wxSize *) 0 ;
3846 int result;
3847 PyObject * obj0 = 0 ;
3848 char *kwnames[] = {
3849 (char *) "self", NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3854 if (SWIG_arg_fail(1)) SWIG_fail;
3855 {
3856 PyThreadState* __tstate = wxPyBeginAllowThreads();
3857 result = (int)((wxSize const *)arg1)->GetHeight();
3858
3859 wxPyEndAllowThreads(__tstate);
3860 if (PyErr_Occurred()) SWIG_fail;
3861 }
3862 {
3863 resultobj = SWIG_From_int((int)(result));
3864 }
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxSize *arg1 = (wxSize *) 0 ;
3874 bool result;
3875 PyObject * obj0 = 0 ;
3876 char *kwnames[] = {
3877 (char *) "self", NULL
3878 };
3879
3880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3882 if (SWIG_arg_fail(1)) SWIG_fail;
3883 {
3884 PyThreadState* __tstate = wxPyBeginAllowThreads();
3885 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3886
3887 wxPyEndAllowThreads(__tstate);
3888 if (PyErr_Occurred()) SWIG_fail;
3889 }
3890 {
3891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3892 }
3893 return resultobj;
3894 fail:
3895 return NULL;
3896 }
3897
3898
3899 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3900 PyObject *resultobj;
3901 wxSize *arg1 = (wxSize *) 0 ;
3902 wxSize *arg2 = 0 ;
3903 wxSize temp2 ;
3904 PyObject * obj0 = 0 ;
3905 PyObject * obj1 = 0 ;
3906 char *kwnames[] = {
3907 (char *) "self",(char *) "size", NULL
3908 };
3909
3910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3912 if (SWIG_arg_fail(1)) SWIG_fail;
3913 {
3914 arg2 = &temp2;
3915 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3916 }
3917 {
3918 PyThreadState* __tstate = wxPyBeginAllowThreads();
3919 (arg1)->SetDefaults((wxSize const &)*arg2);
3920
3921 wxPyEndAllowThreads(__tstate);
3922 if (PyErr_Occurred()) SWIG_fail;
3923 }
3924 Py_INCREF(Py_None); resultobj = Py_None;
3925 return resultobj;
3926 fail:
3927 return NULL;
3928 }
3929
3930
3931 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3932 PyObject *resultobj;
3933 wxSize *arg1 = (wxSize *) 0 ;
3934 PyObject *result;
3935 PyObject * obj0 = 0 ;
3936 char *kwnames[] = {
3937 (char *) "self", NULL
3938 };
3939
3940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3942 if (SWIG_arg_fail(1)) SWIG_fail;
3943 {
3944 PyThreadState* __tstate = wxPyBeginAllowThreads();
3945 result = (PyObject *)wxSize_Get(arg1);
3946
3947 wxPyEndAllowThreads(__tstate);
3948 if (PyErr_Occurred()) SWIG_fail;
3949 }
3950 resultobj = result;
3951 return resultobj;
3952 fail:
3953 return NULL;
3954 }
3955
3956
3957 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3958 PyObject *obj;
3959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3960 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3961 Py_INCREF(obj);
3962 return Py_BuildValue((char *)"");
3963 }
3964 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3965 PyObject *resultobj;
3966 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3967 double arg2 ;
3968 PyObject * obj0 = 0 ;
3969 PyObject * obj1 = 0 ;
3970 char *kwnames[] = {
3971 (char *) "self",(char *) "x", NULL
3972 };
3973
3974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3976 if (SWIG_arg_fail(1)) SWIG_fail;
3977 {
3978 arg2 = (double)(SWIG_As_double(obj1));
3979 if (SWIG_arg_fail(2)) SWIG_fail;
3980 }
3981 if (arg1) (arg1)->x = arg2;
3982
3983 Py_INCREF(Py_None); resultobj = Py_None;
3984 return resultobj;
3985 fail:
3986 return NULL;
3987 }
3988
3989
3990 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3991 PyObject *resultobj;
3992 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3993 double result;
3994 PyObject * obj0 = 0 ;
3995 char *kwnames[] = {
3996 (char *) "self", NULL
3997 };
3998
3999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4001 if (SWIG_arg_fail(1)) SWIG_fail;
4002 result = (double) ((arg1)->x);
4003
4004 {
4005 resultobj = SWIG_From_double((double)(result));
4006 }
4007 return resultobj;
4008 fail:
4009 return NULL;
4010 }
4011
4012
4013 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4014 PyObject *resultobj;
4015 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4016 double arg2 ;
4017 PyObject * obj0 = 0 ;
4018 PyObject * obj1 = 0 ;
4019 char *kwnames[] = {
4020 (char *) "self",(char *) "y", NULL
4021 };
4022
4023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4025 if (SWIG_arg_fail(1)) SWIG_fail;
4026 {
4027 arg2 = (double)(SWIG_As_double(obj1));
4028 if (SWIG_arg_fail(2)) SWIG_fail;
4029 }
4030 if (arg1) (arg1)->y = arg2;
4031
4032 Py_INCREF(Py_None); resultobj = Py_None;
4033 return resultobj;
4034 fail:
4035 return NULL;
4036 }
4037
4038
4039 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4040 PyObject *resultobj;
4041 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4042 double result;
4043 PyObject * obj0 = 0 ;
4044 char *kwnames[] = {
4045 (char *) "self", NULL
4046 };
4047
4048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4050 if (SWIG_arg_fail(1)) SWIG_fail;
4051 result = (double) ((arg1)->y);
4052
4053 {
4054 resultobj = SWIG_From_double((double)(result));
4055 }
4056 return resultobj;
4057 fail:
4058 return NULL;
4059 }
4060
4061
4062 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj;
4064 double arg1 = (double) 0.0 ;
4065 double arg2 = (double) 0.0 ;
4066 wxRealPoint *result;
4067 PyObject * obj0 = 0 ;
4068 PyObject * obj1 = 0 ;
4069 char *kwnames[] = {
4070 (char *) "x",(char *) "y", NULL
4071 };
4072
4073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4074 if (obj0) {
4075 {
4076 arg1 = (double)(SWIG_As_double(obj0));
4077 if (SWIG_arg_fail(1)) SWIG_fail;
4078 }
4079 }
4080 if (obj1) {
4081 {
4082 arg2 = (double)(SWIG_As_double(obj1));
4083 if (SWIG_arg_fail(2)) SWIG_fail;
4084 }
4085 }
4086 {
4087 PyThreadState* __tstate = wxPyBeginAllowThreads();
4088 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4089
4090 wxPyEndAllowThreads(__tstate);
4091 if (PyErr_Occurred()) SWIG_fail;
4092 }
4093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4094 return resultobj;
4095 fail:
4096 return NULL;
4097 }
4098
4099
4100 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj;
4102 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4103 PyObject * obj0 = 0 ;
4104 char *kwnames[] = {
4105 (char *) "self", NULL
4106 };
4107
4108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4110 if (SWIG_arg_fail(1)) SWIG_fail;
4111 {
4112 PyThreadState* __tstate = wxPyBeginAllowThreads();
4113 delete arg1;
4114
4115 wxPyEndAllowThreads(__tstate);
4116 if (PyErr_Occurred()) SWIG_fail;
4117 }
4118 Py_INCREF(Py_None); resultobj = Py_None;
4119 return resultobj;
4120 fail:
4121 return NULL;
4122 }
4123
4124
4125 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4126 PyObject *resultobj;
4127 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4128 wxRealPoint *arg2 = 0 ;
4129 bool result;
4130 wxRealPoint temp2 ;
4131 PyObject * obj0 = 0 ;
4132 PyObject * obj1 = 0 ;
4133 char *kwnames[] = {
4134 (char *) "self",(char *) "pt", NULL
4135 };
4136
4137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4139 if (SWIG_arg_fail(1)) SWIG_fail;
4140 {
4141 arg2 = &temp2;
4142 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4143 }
4144 {
4145 PyThreadState* __tstate = wxPyBeginAllowThreads();
4146 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4147
4148 wxPyEndAllowThreads(__tstate);
4149 if (PyErr_Occurred()) SWIG_fail;
4150 }
4151 {
4152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4153 }
4154 return resultobj;
4155 fail:
4156 return NULL;
4157 }
4158
4159
4160 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4161 PyObject *resultobj;
4162 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4163 wxRealPoint *arg2 = 0 ;
4164 bool result;
4165 wxRealPoint temp2 ;
4166 PyObject * obj0 = 0 ;
4167 PyObject * obj1 = 0 ;
4168 char *kwnames[] = {
4169 (char *) "self",(char *) "pt", NULL
4170 };
4171
4172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4174 if (SWIG_arg_fail(1)) SWIG_fail;
4175 {
4176 arg2 = &temp2;
4177 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4178 }
4179 {
4180 PyThreadState* __tstate = wxPyBeginAllowThreads();
4181 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4182
4183 wxPyEndAllowThreads(__tstate);
4184 if (PyErr_Occurred()) SWIG_fail;
4185 }
4186 {
4187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4188 }
4189 return resultobj;
4190 fail:
4191 return NULL;
4192 }
4193
4194
4195 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4196 PyObject *resultobj;
4197 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4198 wxRealPoint *arg2 = 0 ;
4199 wxRealPoint result;
4200 wxRealPoint temp2 ;
4201 PyObject * obj0 = 0 ;
4202 PyObject * obj1 = 0 ;
4203 char *kwnames[] = {
4204 (char *) "self",(char *) "pt", NULL
4205 };
4206
4207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4209 if (SWIG_arg_fail(1)) SWIG_fail;
4210 {
4211 arg2 = &temp2;
4212 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4213 }
4214 {
4215 PyThreadState* __tstate = wxPyBeginAllowThreads();
4216 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4217
4218 wxPyEndAllowThreads(__tstate);
4219 if (PyErr_Occurred()) SWIG_fail;
4220 }
4221 {
4222 wxRealPoint * resultptr;
4223 resultptr = new wxRealPoint((wxRealPoint &)(result));
4224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4225 }
4226 return resultobj;
4227 fail:
4228 return NULL;
4229 }
4230
4231
4232 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4233 PyObject *resultobj;
4234 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4235 wxRealPoint *arg2 = 0 ;
4236 wxRealPoint result;
4237 wxRealPoint temp2 ;
4238 PyObject * obj0 = 0 ;
4239 PyObject * obj1 = 0 ;
4240 char *kwnames[] = {
4241 (char *) "self",(char *) "pt", NULL
4242 };
4243
4244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4246 if (SWIG_arg_fail(1)) SWIG_fail;
4247 {
4248 arg2 = &temp2;
4249 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4250 }
4251 {
4252 PyThreadState* __tstate = wxPyBeginAllowThreads();
4253 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4254
4255 wxPyEndAllowThreads(__tstate);
4256 if (PyErr_Occurred()) SWIG_fail;
4257 }
4258 {
4259 wxRealPoint * resultptr;
4260 resultptr = new wxRealPoint((wxRealPoint &)(result));
4261 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4262 }
4263 return resultobj;
4264 fail:
4265 return NULL;
4266 }
4267
4268
4269 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4270 PyObject *resultobj;
4271 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4272 double arg2 ;
4273 double arg3 ;
4274 PyObject * obj0 = 0 ;
4275 PyObject * obj1 = 0 ;
4276 PyObject * obj2 = 0 ;
4277 char *kwnames[] = {
4278 (char *) "self",(char *) "x",(char *) "y", NULL
4279 };
4280
4281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4283 if (SWIG_arg_fail(1)) SWIG_fail;
4284 {
4285 arg2 = (double)(SWIG_As_double(obj1));
4286 if (SWIG_arg_fail(2)) SWIG_fail;
4287 }
4288 {
4289 arg3 = (double)(SWIG_As_double(obj2));
4290 if (SWIG_arg_fail(3)) SWIG_fail;
4291 }
4292 {
4293 PyThreadState* __tstate = wxPyBeginAllowThreads();
4294 wxRealPoint_Set(arg1,arg2,arg3);
4295
4296 wxPyEndAllowThreads(__tstate);
4297 if (PyErr_Occurred()) SWIG_fail;
4298 }
4299 Py_INCREF(Py_None); resultobj = Py_None;
4300 return resultobj;
4301 fail:
4302 return NULL;
4303 }
4304
4305
4306 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4307 PyObject *resultobj;
4308 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4309 PyObject *result;
4310 PyObject * obj0 = 0 ;
4311 char *kwnames[] = {
4312 (char *) "self", NULL
4313 };
4314
4315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4317 if (SWIG_arg_fail(1)) SWIG_fail;
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 result = (PyObject *)wxRealPoint_Get(arg1);
4321
4322 wxPyEndAllowThreads(__tstate);
4323 if (PyErr_Occurred()) SWIG_fail;
4324 }
4325 resultobj = result;
4326 return resultobj;
4327 fail:
4328 return NULL;
4329 }
4330
4331
4332 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4333 PyObject *obj;
4334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4335 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4336 Py_INCREF(obj);
4337 return Py_BuildValue((char *)"");
4338 }
4339 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4340 PyObject *resultobj;
4341 wxPoint *arg1 = (wxPoint *) 0 ;
4342 int arg2 ;
4343 PyObject * obj0 = 0 ;
4344 PyObject * obj1 = 0 ;
4345 char *kwnames[] = {
4346 (char *) "self",(char *) "x", NULL
4347 };
4348
4349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4351 if (SWIG_arg_fail(1)) SWIG_fail;
4352 {
4353 arg2 = (int)(SWIG_As_int(obj1));
4354 if (SWIG_arg_fail(2)) SWIG_fail;
4355 }
4356 if (arg1) (arg1)->x = arg2;
4357
4358 Py_INCREF(Py_None); resultobj = Py_None;
4359 return resultobj;
4360 fail:
4361 return NULL;
4362 }
4363
4364
4365 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj;
4367 wxPoint *arg1 = (wxPoint *) 0 ;
4368 int result;
4369 PyObject * obj0 = 0 ;
4370 char *kwnames[] = {
4371 (char *) "self", NULL
4372 };
4373
4374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4376 if (SWIG_arg_fail(1)) SWIG_fail;
4377 result = (int) ((arg1)->x);
4378
4379 {
4380 resultobj = SWIG_From_int((int)(result));
4381 }
4382 return resultobj;
4383 fail:
4384 return NULL;
4385 }
4386
4387
4388 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4389 PyObject *resultobj;
4390 wxPoint *arg1 = (wxPoint *) 0 ;
4391 int arg2 ;
4392 PyObject * obj0 = 0 ;
4393 PyObject * obj1 = 0 ;
4394 char *kwnames[] = {
4395 (char *) "self",(char *) "y", NULL
4396 };
4397
4398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4400 if (SWIG_arg_fail(1)) SWIG_fail;
4401 {
4402 arg2 = (int)(SWIG_As_int(obj1));
4403 if (SWIG_arg_fail(2)) SWIG_fail;
4404 }
4405 if (arg1) (arg1)->y = arg2;
4406
4407 Py_INCREF(Py_None); resultobj = Py_None;
4408 return resultobj;
4409 fail:
4410 return NULL;
4411 }
4412
4413
4414 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4415 PyObject *resultobj;
4416 wxPoint *arg1 = (wxPoint *) 0 ;
4417 int result;
4418 PyObject * obj0 = 0 ;
4419 char *kwnames[] = {
4420 (char *) "self", NULL
4421 };
4422
4423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4425 if (SWIG_arg_fail(1)) SWIG_fail;
4426 result = (int) ((arg1)->y);
4427
4428 {
4429 resultobj = SWIG_From_int((int)(result));
4430 }
4431 return resultobj;
4432 fail:
4433 return NULL;
4434 }
4435
4436
4437 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4438 PyObject *resultobj;
4439 int arg1 = (int) 0 ;
4440 int arg2 = (int) 0 ;
4441 wxPoint *result;
4442 PyObject * obj0 = 0 ;
4443 PyObject * obj1 = 0 ;
4444 char *kwnames[] = {
4445 (char *) "x",(char *) "y", NULL
4446 };
4447
4448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4449 if (obj0) {
4450 {
4451 arg1 = (int)(SWIG_As_int(obj0));
4452 if (SWIG_arg_fail(1)) SWIG_fail;
4453 }
4454 }
4455 if (obj1) {
4456 {
4457 arg2 = (int)(SWIG_As_int(obj1));
4458 if (SWIG_arg_fail(2)) SWIG_fail;
4459 }
4460 }
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 result = (wxPoint *)new wxPoint(arg1,arg2);
4464
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4476 PyObject *resultobj;
4477 wxPoint *arg1 = (wxPoint *) 0 ;
4478 PyObject * obj0 = 0 ;
4479 char *kwnames[] = {
4480 (char *) "self", NULL
4481 };
4482
4483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4485 if (SWIG_arg_fail(1)) SWIG_fail;
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 delete arg1;
4489
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 Py_INCREF(Py_None); resultobj = Py_None;
4494 return resultobj;
4495 fail:
4496 return NULL;
4497 }
4498
4499
4500 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4501 PyObject *resultobj;
4502 wxPoint *arg1 = (wxPoint *) 0 ;
4503 wxPoint *arg2 = 0 ;
4504 bool result;
4505 wxPoint temp2 ;
4506 PyObject * obj0 = 0 ;
4507 PyObject * obj1 = 0 ;
4508 char *kwnames[] = {
4509 (char *) "self",(char *) "pt", NULL
4510 };
4511
4512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4514 if (SWIG_arg_fail(1)) SWIG_fail;
4515 {
4516 arg2 = &temp2;
4517 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4518 }
4519 {
4520 PyThreadState* __tstate = wxPyBeginAllowThreads();
4521 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4522
4523 wxPyEndAllowThreads(__tstate);
4524 if (PyErr_Occurred()) SWIG_fail;
4525 }
4526 {
4527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4528 }
4529 return resultobj;
4530 fail:
4531 return NULL;
4532 }
4533
4534
4535 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4536 PyObject *resultobj;
4537 wxPoint *arg1 = (wxPoint *) 0 ;
4538 wxPoint *arg2 = 0 ;
4539 bool result;
4540 wxPoint temp2 ;
4541 PyObject * obj0 = 0 ;
4542 PyObject * obj1 = 0 ;
4543 char *kwnames[] = {
4544 (char *) "self",(char *) "pt", NULL
4545 };
4546
4547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4549 if (SWIG_arg_fail(1)) SWIG_fail;
4550 {
4551 arg2 = &temp2;
4552 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4553 }
4554 {
4555 PyThreadState* __tstate = wxPyBeginAllowThreads();
4556 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4557
4558 wxPyEndAllowThreads(__tstate);
4559 if (PyErr_Occurred()) SWIG_fail;
4560 }
4561 {
4562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4563 }
4564 return resultobj;
4565 fail:
4566 return NULL;
4567 }
4568
4569
4570 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4571 PyObject *resultobj;
4572 wxPoint *arg1 = (wxPoint *) 0 ;
4573 wxPoint *arg2 = 0 ;
4574 wxPoint result;
4575 wxPoint temp2 ;
4576 PyObject * obj0 = 0 ;
4577 PyObject * obj1 = 0 ;
4578 char *kwnames[] = {
4579 (char *) "self",(char *) "pt", NULL
4580 };
4581
4582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4584 if (SWIG_arg_fail(1)) SWIG_fail;
4585 {
4586 arg2 = &temp2;
4587 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4588 }
4589 {
4590 PyThreadState* __tstate = wxPyBeginAllowThreads();
4591 result = (arg1)->operator +((wxPoint const &)*arg2);
4592
4593 wxPyEndAllowThreads(__tstate);
4594 if (PyErr_Occurred()) SWIG_fail;
4595 }
4596 {
4597 wxPoint * resultptr;
4598 resultptr = new wxPoint((wxPoint &)(result));
4599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4600 }
4601 return resultobj;
4602 fail:
4603 return NULL;
4604 }
4605
4606
4607 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4608 PyObject *resultobj;
4609 wxPoint *arg1 = (wxPoint *) 0 ;
4610 wxPoint *arg2 = 0 ;
4611 wxPoint result;
4612 wxPoint temp2 ;
4613 PyObject * obj0 = 0 ;
4614 PyObject * obj1 = 0 ;
4615 char *kwnames[] = {
4616 (char *) "self",(char *) "pt", NULL
4617 };
4618
4619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4621 if (SWIG_arg_fail(1)) SWIG_fail;
4622 {
4623 arg2 = &temp2;
4624 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4625 }
4626 {
4627 PyThreadState* __tstate = wxPyBeginAllowThreads();
4628 result = (arg1)->operator -((wxPoint const &)*arg2);
4629
4630 wxPyEndAllowThreads(__tstate);
4631 if (PyErr_Occurred()) SWIG_fail;
4632 }
4633 {
4634 wxPoint * resultptr;
4635 resultptr = new wxPoint((wxPoint &)(result));
4636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4637 }
4638 return resultobj;
4639 fail:
4640 return NULL;
4641 }
4642
4643
4644 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4645 PyObject *resultobj;
4646 wxPoint *arg1 = (wxPoint *) 0 ;
4647 wxPoint *arg2 = 0 ;
4648 wxPoint *result;
4649 wxPoint temp2 ;
4650 PyObject * obj0 = 0 ;
4651 PyObject * obj1 = 0 ;
4652 char *kwnames[] = {
4653 (char *) "self",(char *) "pt", NULL
4654 };
4655
4656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4658 if (SWIG_arg_fail(1)) SWIG_fail;
4659 {
4660 arg2 = &temp2;
4661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4662 }
4663 {
4664 PyThreadState* __tstate = wxPyBeginAllowThreads();
4665 {
4666 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4667 result = (wxPoint *) &_result_ref;
4668 }
4669
4670 wxPyEndAllowThreads(__tstate);
4671 if (PyErr_Occurred()) SWIG_fail;
4672 }
4673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4674 return resultobj;
4675 fail:
4676 return NULL;
4677 }
4678
4679
4680 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4681 PyObject *resultobj;
4682 wxPoint *arg1 = (wxPoint *) 0 ;
4683 wxPoint *arg2 = 0 ;
4684 wxPoint *result;
4685 wxPoint temp2 ;
4686 PyObject * obj0 = 0 ;
4687 PyObject * obj1 = 0 ;
4688 char *kwnames[] = {
4689 (char *) "self",(char *) "pt", NULL
4690 };
4691
4692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4694 if (SWIG_arg_fail(1)) SWIG_fail;
4695 {
4696 arg2 = &temp2;
4697 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4698 }
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 {
4702 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4703 result = (wxPoint *) &_result_ref;
4704 }
4705
4706 wxPyEndAllowThreads(__tstate);
4707 if (PyErr_Occurred()) SWIG_fail;
4708 }
4709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4717 PyObject *resultobj;
4718 wxPoint *arg1 = (wxPoint *) 0 ;
4719 long arg2 ;
4720 long arg3 ;
4721 PyObject * obj0 = 0 ;
4722 PyObject * obj1 = 0 ;
4723 PyObject * obj2 = 0 ;
4724 char *kwnames[] = {
4725 (char *) "self",(char *) "x",(char *) "y", NULL
4726 };
4727
4728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4730 if (SWIG_arg_fail(1)) SWIG_fail;
4731 {
4732 arg2 = (long)(SWIG_As_long(obj1));
4733 if (SWIG_arg_fail(2)) SWIG_fail;
4734 }
4735 {
4736 arg3 = (long)(SWIG_As_long(obj2));
4737 if (SWIG_arg_fail(3)) SWIG_fail;
4738 }
4739 {
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 wxPoint_Set(arg1,arg2,arg3);
4742
4743 wxPyEndAllowThreads(__tstate);
4744 if (PyErr_Occurred()) SWIG_fail;
4745 }
4746 Py_INCREF(Py_None); resultobj = Py_None;
4747 return resultobj;
4748 fail:
4749 return NULL;
4750 }
4751
4752
4753 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj;
4755 wxPoint *arg1 = (wxPoint *) 0 ;
4756 PyObject *result;
4757 PyObject * obj0 = 0 ;
4758 char *kwnames[] = {
4759 (char *) "self", NULL
4760 };
4761
4762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4764 if (SWIG_arg_fail(1)) SWIG_fail;
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (PyObject *)wxPoint_Get(arg1);
4768
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 resultobj = result;
4773 return resultobj;
4774 fail:
4775 return NULL;
4776 }
4777
4778
4779 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4780 PyObject *obj;
4781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4782 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4783 Py_INCREF(obj);
4784 return Py_BuildValue((char *)"");
4785 }
4786 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4787 PyObject *resultobj;
4788 int arg1 = (int) 0 ;
4789 int arg2 = (int) 0 ;
4790 int arg3 = (int) 0 ;
4791 int arg4 = (int) 0 ;
4792 wxRect *result;
4793 PyObject * obj0 = 0 ;
4794 PyObject * obj1 = 0 ;
4795 PyObject * obj2 = 0 ;
4796 PyObject * obj3 = 0 ;
4797 char *kwnames[] = {
4798 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4799 };
4800
4801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4802 if (obj0) {
4803 {
4804 arg1 = (int)(SWIG_As_int(obj0));
4805 if (SWIG_arg_fail(1)) SWIG_fail;
4806 }
4807 }
4808 if (obj1) {
4809 {
4810 arg2 = (int)(SWIG_As_int(obj1));
4811 if (SWIG_arg_fail(2)) SWIG_fail;
4812 }
4813 }
4814 if (obj2) {
4815 {
4816 arg3 = (int)(SWIG_As_int(obj2));
4817 if (SWIG_arg_fail(3)) SWIG_fail;
4818 }
4819 }
4820 if (obj3) {
4821 {
4822 arg4 = (int)(SWIG_As_int(obj3));
4823 if (SWIG_arg_fail(4)) SWIG_fail;
4824 }
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4829
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4834 return resultobj;
4835 fail:
4836 return NULL;
4837 }
4838
4839
4840 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4841 PyObject *resultobj;
4842 wxPoint *arg1 = 0 ;
4843 wxPoint *arg2 = 0 ;
4844 wxRect *result;
4845 wxPoint temp1 ;
4846 wxPoint temp2 ;
4847 PyObject * obj0 = 0 ;
4848 PyObject * obj1 = 0 ;
4849 char *kwnames[] = {
4850 (char *) "topLeft",(char *) "bottomRight", NULL
4851 };
4852
4853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4854 {
4855 arg1 = &temp1;
4856 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4857 }
4858 {
4859 arg2 = &temp2;
4860 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4861 }
4862 {
4863 PyThreadState* __tstate = wxPyBeginAllowThreads();
4864 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4865
4866 wxPyEndAllowThreads(__tstate);
4867 if (PyErr_Occurred()) SWIG_fail;
4868 }
4869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4870 return resultobj;
4871 fail:
4872 return NULL;
4873 }
4874
4875
4876 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4877 PyObject *resultobj;
4878 wxPoint *arg1 = 0 ;
4879 wxSize *arg2 = 0 ;
4880 wxRect *result;
4881 wxPoint temp1 ;
4882 wxSize temp2 ;
4883 PyObject * obj0 = 0 ;
4884 PyObject * obj1 = 0 ;
4885 char *kwnames[] = {
4886 (char *) "pos",(char *) "size", NULL
4887 };
4888
4889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4890 {
4891 arg1 = &temp1;
4892 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4893 }
4894 {
4895 arg2 = &temp2;
4896 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4897 }
4898 {
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj;
4914 wxSize *arg1 = 0 ;
4915 wxRect *result;
4916 wxSize temp1 ;
4917 PyObject * obj0 = 0 ;
4918 char *kwnames[] = {
4919 (char *) "size", NULL
4920 };
4921
4922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4923 {
4924 arg1 = &temp1;
4925 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4926 }
4927 {
4928 PyThreadState* __tstate = wxPyBeginAllowThreads();
4929 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4930
4931 wxPyEndAllowThreads(__tstate);
4932 if (PyErr_Occurred()) SWIG_fail;
4933 }
4934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4935 return resultobj;
4936 fail:
4937 return NULL;
4938 }
4939
4940
4941 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4942 PyObject *resultobj;
4943 wxRect *arg1 = (wxRect *) 0 ;
4944 PyObject * obj0 = 0 ;
4945 char *kwnames[] = {
4946 (char *) "self", NULL
4947 };
4948
4949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4951 if (SWIG_arg_fail(1)) SWIG_fail;
4952 {
4953 PyThreadState* __tstate = wxPyBeginAllowThreads();
4954 delete arg1;
4955
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 Py_INCREF(Py_None); resultobj = Py_None;
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj;
4968 wxRect *arg1 = (wxRect *) 0 ;
4969 int result;
4970 PyObject * obj0 = 0 ;
4971 char *kwnames[] = {
4972 (char *) "self", NULL
4973 };
4974
4975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4977 if (SWIG_arg_fail(1)) SWIG_fail;
4978 {
4979 PyThreadState* __tstate = wxPyBeginAllowThreads();
4980 result = (int)((wxRect const *)arg1)->GetX();
4981
4982 wxPyEndAllowThreads(__tstate);
4983 if (PyErr_Occurred()) SWIG_fail;
4984 }
4985 {
4986 resultobj = SWIG_From_int((int)(result));
4987 }
4988 return resultobj;
4989 fail:
4990 return NULL;
4991 }
4992
4993
4994 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj;
4996 wxRect *arg1 = (wxRect *) 0 ;
4997 int arg2 ;
4998 PyObject * obj0 = 0 ;
4999 PyObject * obj1 = 0 ;
5000 char *kwnames[] = {
5001 (char *) "self",(char *) "x", NULL
5002 };
5003
5004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5006 if (SWIG_arg_fail(1)) SWIG_fail;
5007 {
5008 arg2 = (int)(SWIG_As_int(obj1));
5009 if (SWIG_arg_fail(2)) SWIG_fail;
5010 }
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 (arg1)->SetX(arg2);
5014
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 Py_INCREF(Py_None); resultobj = Py_None;
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5026 PyObject *resultobj;
5027 wxRect *arg1 = (wxRect *) 0 ;
5028 int result;
5029 PyObject * obj0 = 0 ;
5030 char *kwnames[] = {
5031 (char *) "self", NULL
5032 };
5033
5034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5036 if (SWIG_arg_fail(1)) SWIG_fail;
5037 {
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = (int)(arg1)->GetY();
5040
5041 wxPyEndAllowThreads(__tstate);
5042 if (PyErr_Occurred()) SWIG_fail;
5043 }
5044 {
5045 resultobj = SWIG_From_int((int)(result));
5046 }
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5054 PyObject *resultobj;
5055 wxRect *arg1 = (wxRect *) 0 ;
5056 int arg2 ;
5057 PyObject * obj0 = 0 ;
5058 PyObject * obj1 = 0 ;
5059 char *kwnames[] = {
5060 (char *) "self",(char *) "y", NULL
5061 };
5062
5063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5065 if (SWIG_arg_fail(1)) SWIG_fail;
5066 {
5067 arg2 = (int)(SWIG_As_int(obj1));
5068 if (SWIG_arg_fail(2)) SWIG_fail;
5069 }
5070 {
5071 PyThreadState* __tstate = wxPyBeginAllowThreads();
5072 (arg1)->SetY(arg2);
5073
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 Py_INCREF(Py_None); resultobj = Py_None;
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 wxRect *arg1 = (wxRect *) 0 ;
5087 int result;
5088 PyObject * obj0 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "self", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5095 if (SWIG_arg_fail(1)) SWIG_fail;
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (int)((wxRect const *)arg1)->GetWidth();
5099
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 resultobj = SWIG_From_int((int)(result));
5105 }
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj;
5114 wxRect *arg1 = (wxRect *) 0 ;
5115 int arg2 ;
5116 PyObject * obj0 = 0 ;
5117 PyObject * obj1 = 0 ;
5118 char *kwnames[] = {
5119 (char *) "self",(char *) "w", NULL
5120 };
5121
5122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5124 if (SWIG_arg_fail(1)) SWIG_fail;
5125 {
5126 arg2 = (int)(SWIG_As_int(obj1));
5127 if (SWIG_arg_fail(2)) SWIG_fail;
5128 }
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 (arg1)->SetWidth(arg2);
5132
5133 wxPyEndAllowThreads(__tstate);
5134 if (PyErr_Occurred()) SWIG_fail;
5135 }
5136 Py_INCREF(Py_None); resultobj = Py_None;
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj;
5145 wxRect *arg1 = (wxRect *) 0 ;
5146 int result;
5147 PyObject * obj0 = 0 ;
5148 char *kwnames[] = {
5149 (char *) "self", NULL
5150 };
5151
5152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5154 if (SWIG_arg_fail(1)) SWIG_fail;
5155 {
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 result = (int)((wxRect const *)arg1)->GetHeight();
5158
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 {
5163 resultobj = SWIG_From_int((int)(result));
5164 }
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5172 PyObject *resultobj;
5173 wxRect *arg1 = (wxRect *) 0 ;
5174 int arg2 ;
5175 PyObject * obj0 = 0 ;
5176 PyObject * obj1 = 0 ;
5177 char *kwnames[] = {
5178 (char *) "self",(char *) "h", NULL
5179 };
5180
5181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5183 if (SWIG_arg_fail(1)) SWIG_fail;
5184 {
5185 arg2 = (int)(SWIG_As_int(obj1));
5186 if (SWIG_arg_fail(2)) SWIG_fail;
5187 }
5188 {
5189 PyThreadState* __tstate = wxPyBeginAllowThreads();
5190 (arg1)->SetHeight(arg2);
5191
5192 wxPyEndAllowThreads(__tstate);
5193 if (PyErr_Occurred()) SWIG_fail;
5194 }
5195 Py_INCREF(Py_None); resultobj = Py_None;
5196 return resultobj;
5197 fail:
5198 return NULL;
5199 }
5200
5201
5202 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5203 PyObject *resultobj;
5204 wxRect *arg1 = (wxRect *) 0 ;
5205 wxPoint result;
5206 PyObject * obj0 = 0 ;
5207 char *kwnames[] = {
5208 (char *) "self", NULL
5209 };
5210
5211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5213 if (SWIG_arg_fail(1)) SWIG_fail;
5214 {
5215 PyThreadState* __tstate = wxPyBeginAllowThreads();
5216 result = ((wxRect const *)arg1)->GetPosition();
5217
5218 wxPyEndAllowThreads(__tstate);
5219 if (PyErr_Occurred()) SWIG_fail;
5220 }
5221 {
5222 wxPoint * resultptr;
5223 resultptr = new wxPoint((wxPoint &)(result));
5224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5225 }
5226 return resultobj;
5227 fail:
5228 return NULL;
5229 }
5230
5231
5232 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5233 PyObject *resultobj;
5234 wxRect *arg1 = (wxRect *) 0 ;
5235 wxPoint *arg2 = 0 ;
5236 wxPoint temp2 ;
5237 PyObject * obj0 = 0 ;
5238 PyObject * obj1 = 0 ;
5239 char *kwnames[] = {
5240 (char *) "self",(char *) "p", NULL
5241 };
5242
5243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5245 if (SWIG_arg_fail(1)) SWIG_fail;
5246 {
5247 arg2 = &temp2;
5248 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5249 }
5250 {
5251 PyThreadState* __tstate = wxPyBeginAllowThreads();
5252 (arg1)->SetPosition((wxPoint const &)*arg2);
5253
5254 wxPyEndAllowThreads(__tstate);
5255 if (PyErr_Occurred()) SWIG_fail;
5256 }
5257 Py_INCREF(Py_None); resultobj = Py_None;
5258 return resultobj;
5259 fail:
5260 return NULL;
5261 }
5262
5263
5264 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5265 PyObject *resultobj;
5266 wxRect *arg1 = (wxRect *) 0 ;
5267 wxSize result;
5268 PyObject * obj0 = 0 ;
5269 char *kwnames[] = {
5270 (char *) "self", NULL
5271 };
5272
5273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5275 if (SWIG_arg_fail(1)) SWIG_fail;
5276 {
5277 PyThreadState* __tstate = wxPyBeginAllowThreads();
5278 result = ((wxRect const *)arg1)->GetSize();
5279
5280 wxPyEndAllowThreads(__tstate);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 {
5284 wxSize * resultptr;
5285 resultptr = new wxSize((wxSize &)(result));
5286 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5287 }
5288 return resultobj;
5289 fail:
5290 return NULL;
5291 }
5292
5293
5294 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5295 PyObject *resultobj;
5296 wxRect *arg1 = (wxRect *) 0 ;
5297 wxSize *arg2 = 0 ;
5298 wxSize temp2 ;
5299 PyObject * obj0 = 0 ;
5300 PyObject * obj1 = 0 ;
5301 char *kwnames[] = {
5302 (char *) "self",(char *) "s", NULL
5303 };
5304
5305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5307 if (SWIG_arg_fail(1)) SWIG_fail;
5308 {
5309 arg2 = &temp2;
5310 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5311 }
5312 {
5313 PyThreadState* __tstate = wxPyBeginAllowThreads();
5314 (arg1)->SetSize((wxSize const &)*arg2);
5315
5316 wxPyEndAllowThreads(__tstate);
5317 if (PyErr_Occurred()) SWIG_fail;
5318 }
5319 Py_INCREF(Py_None); resultobj = Py_None;
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5327 PyObject *resultobj;
5328 wxRect *arg1 = (wxRect *) 0 ;
5329 bool result;
5330 PyObject * obj0 = 0 ;
5331 char *kwnames[] = {
5332 (char *) "self", NULL
5333 };
5334
5335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5337 if (SWIG_arg_fail(1)) SWIG_fail;
5338 {
5339 PyThreadState* __tstate = wxPyBeginAllowThreads();
5340 result = (bool)((wxRect const *)arg1)->IsEmpty();
5341
5342 wxPyEndAllowThreads(__tstate);
5343 if (PyErr_Occurred()) SWIG_fail;
5344 }
5345 {
5346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5347 }
5348 return resultobj;
5349 fail:
5350 return NULL;
5351 }
5352
5353
5354 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5355 PyObject *resultobj;
5356 wxRect *arg1 = (wxRect *) 0 ;
5357 wxPoint result;
5358 PyObject * obj0 = 0 ;
5359 char *kwnames[] = {
5360 (char *) "self", NULL
5361 };
5362
5363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5365 if (SWIG_arg_fail(1)) SWIG_fail;
5366 {
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 result = ((wxRect const *)arg1)->GetTopLeft();
5369
5370 wxPyEndAllowThreads(__tstate);
5371 if (PyErr_Occurred()) SWIG_fail;
5372 }
5373 {
5374 wxPoint * resultptr;
5375 resultptr = new wxPoint((wxPoint &)(result));
5376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5377 }
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5385 PyObject *resultobj;
5386 wxRect *arg1 = (wxRect *) 0 ;
5387 wxPoint *arg2 = 0 ;
5388 wxPoint temp2 ;
5389 PyObject * obj0 = 0 ;
5390 PyObject * obj1 = 0 ;
5391 char *kwnames[] = {
5392 (char *) "self",(char *) "p", NULL
5393 };
5394
5395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5397 if (SWIG_arg_fail(1)) SWIG_fail;
5398 {
5399 arg2 = &temp2;
5400 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5401 }
5402 {
5403 PyThreadState* __tstate = wxPyBeginAllowThreads();
5404 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5405
5406 wxPyEndAllowThreads(__tstate);
5407 if (PyErr_Occurred()) SWIG_fail;
5408 }
5409 Py_INCREF(Py_None); resultobj = Py_None;
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5417 PyObject *resultobj;
5418 wxRect *arg1 = (wxRect *) 0 ;
5419 wxPoint result;
5420 PyObject * obj0 = 0 ;
5421 char *kwnames[] = {
5422 (char *) "self", NULL
5423 };
5424
5425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5427 if (SWIG_arg_fail(1)) SWIG_fail;
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = ((wxRect const *)arg1)->GetBottomRight();
5431
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 wxPoint * resultptr;
5437 resultptr = new wxPoint((wxPoint &)(result));
5438 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5439 }
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj;
5448 wxRect *arg1 = (wxRect *) 0 ;
5449 wxPoint *arg2 = 0 ;
5450 wxPoint temp2 ;
5451 PyObject * obj0 = 0 ;
5452 PyObject * obj1 = 0 ;
5453 char *kwnames[] = {
5454 (char *) "self",(char *) "p", NULL
5455 };
5456
5457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5459 if (SWIG_arg_fail(1)) SWIG_fail;
5460 {
5461 arg2 = &temp2;
5462 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5463 }
5464 {
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5467
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 Py_INCREF(Py_None); resultobj = Py_None;
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj;
5480 wxRect *arg1 = (wxRect *) 0 ;
5481 int result;
5482 PyObject * obj0 = 0 ;
5483 char *kwnames[] = {
5484 (char *) "self", NULL
5485 };
5486
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5489 if (SWIG_arg_fail(1)) SWIG_fail;
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (int)((wxRect const *)arg1)->GetLeft();
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = SWIG_From_int((int)(result));
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxRect *arg1 = (wxRect *) 0 ;
5509 int result;
5510 PyObject * obj0 = 0 ;
5511 char *kwnames[] = {
5512 (char *) "self", NULL
5513 };
5514
5515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5517 if (SWIG_arg_fail(1)) SWIG_fail;
5518 {
5519 PyThreadState* __tstate = wxPyBeginAllowThreads();
5520 result = (int)((wxRect const *)arg1)->GetTop();
5521
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 {
5526 resultobj = SWIG_From_int((int)(result));
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 wxRect *arg1 = (wxRect *) 0 ;
5537 int result;
5538 PyObject * obj0 = 0 ;
5539 char *kwnames[] = {
5540 (char *) "self", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5545 if (SWIG_arg_fail(1)) SWIG_fail;
5546 {
5547 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 result = (int)((wxRect const *)arg1)->GetBottom();
5549
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 resultobj = SWIG_From_int((int)(result));
5555 }
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 wxRect *arg1 = (wxRect *) 0 ;
5565 int result;
5566 PyObject * obj0 = 0 ;
5567 char *kwnames[] = {
5568 (char *) "self", NULL
5569 };
5570
5571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5573 if (SWIG_arg_fail(1)) SWIG_fail;
5574 {
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 result = (int)((wxRect const *)arg1)->GetRight();
5577
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 {
5582 resultobj = SWIG_From_int((int)(result));
5583 }
5584 return resultobj;
5585 fail:
5586 return NULL;
5587 }
5588
5589
5590 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5591 PyObject *resultobj;
5592 wxRect *arg1 = (wxRect *) 0 ;
5593 int arg2 ;
5594 PyObject * obj0 = 0 ;
5595 PyObject * obj1 = 0 ;
5596 char *kwnames[] = {
5597 (char *) "self",(char *) "left", NULL
5598 };
5599
5600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5602 if (SWIG_arg_fail(1)) SWIG_fail;
5603 {
5604 arg2 = (int)(SWIG_As_int(obj1));
5605 if (SWIG_arg_fail(2)) SWIG_fail;
5606 }
5607 {
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 (arg1)->SetLeft(arg2);
5610
5611 wxPyEndAllowThreads(__tstate);
5612 if (PyErr_Occurred()) SWIG_fail;
5613 }
5614 Py_INCREF(Py_None); resultobj = Py_None;
5615 return resultobj;
5616 fail:
5617 return NULL;
5618 }
5619
5620
5621 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5622 PyObject *resultobj;
5623 wxRect *arg1 = (wxRect *) 0 ;
5624 int arg2 ;
5625 PyObject * obj0 = 0 ;
5626 PyObject * obj1 = 0 ;
5627 char *kwnames[] = {
5628 (char *) "self",(char *) "right", NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5633 if (SWIG_arg_fail(1)) SWIG_fail;
5634 {
5635 arg2 = (int)(SWIG_As_int(obj1));
5636 if (SWIG_arg_fail(2)) SWIG_fail;
5637 }
5638 {
5639 PyThreadState* __tstate = wxPyBeginAllowThreads();
5640 (arg1)->SetRight(arg2);
5641
5642 wxPyEndAllowThreads(__tstate);
5643 if (PyErr_Occurred()) SWIG_fail;
5644 }
5645 Py_INCREF(Py_None); resultobj = Py_None;
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5653 PyObject *resultobj;
5654 wxRect *arg1 = (wxRect *) 0 ;
5655 int arg2 ;
5656 PyObject * obj0 = 0 ;
5657 PyObject * obj1 = 0 ;
5658 char *kwnames[] = {
5659 (char *) "self",(char *) "top", NULL
5660 };
5661
5662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5664 if (SWIG_arg_fail(1)) SWIG_fail;
5665 {
5666 arg2 = (int)(SWIG_As_int(obj1));
5667 if (SWIG_arg_fail(2)) SWIG_fail;
5668 }
5669 {
5670 PyThreadState* __tstate = wxPyBeginAllowThreads();
5671 (arg1)->SetTop(arg2);
5672
5673 wxPyEndAllowThreads(__tstate);
5674 if (PyErr_Occurred()) SWIG_fail;
5675 }
5676 Py_INCREF(Py_None); resultobj = Py_None;
5677 return resultobj;
5678 fail:
5679 return NULL;
5680 }
5681
5682
5683 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5684 PyObject *resultobj;
5685 wxRect *arg1 = (wxRect *) 0 ;
5686 int arg2 ;
5687 PyObject * obj0 = 0 ;
5688 PyObject * obj1 = 0 ;
5689 char *kwnames[] = {
5690 (char *) "self",(char *) "bottom", NULL
5691 };
5692
5693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5695 if (SWIG_arg_fail(1)) SWIG_fail;
5696 {
5697 arg2 = (int)(SWIG_As_int(obj1));
5698 if (SWIG_arg_fail(2)) SWIG_fail;
5699 }
5700 {
5701 PyThreadState* __tstate = wxPyBeginAllowThreads();
5702 (arg1)->SetBottom(arg2);
5703
5704 wxPyEndAllowThreads(__tstate);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 Py_INCREF(Py_None); resultobj = Py_None;
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5715 PyObject *resultobj;
5716 wxRect *arg1 = (wxRect *) 0 ;
5717 int arg2 ;
5718 int arg3 ;
5719 wxRect *result;
5720 PyObject * obj0 = 0 ;
5721 PyObject * obj1 = 0 ;
5722 PyObject * obj2 = 0 ;
5723 char *kwnames[] = {
5724 (char *) "self",(char *) "dx",(char *) "dy", NULL
5725 };
5726
5727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5729 if (SWIG_arg_fail(1)) SWIG_fail;
5730 {
5731 arg2 = (int)(SWIG_As_int(obj1));
5732 if (SWIG_arg_fail(2)) SWIG_fail;
5733 }
5734 {
5735 arg3 = (int)(SWIG_As_int(obj2));
5736 if (SWIG_arg_fail(3)) SWIG_fail;
5737 }
5738 {
5739 PyThreadState* __tstate = wxPyBeginAllowThreads();
5740 {
5741 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5742 result = (wxRect *) &_result_ref;
5743 }
5744
5745 wxPyEndAllowThreads(__tstate);
5746 if (PyErr_Occurred()) SWIG_fail;
5747 }
5748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5749 return resultobj;
5750 fail:
5751 return NULL;
5752 }
5753
5754
5755 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5756 PyObject *resultobj;
5757 wxRect *arg1 = (wxRect *) 0 ;
5758 int arg2 ;
5759 int arg3 ;
5760 wxRect *result;
5761 PyObject * obj0 = 0 ;
5762 PyObject * obj1 = 0 ;
5763 PyObject * obj2 = 0 ;
5764 char *kwnames[] = {
5765 (char *) "self",(char *) "dx",(char *) "dy", NULL
5766 };
5767
5768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) 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 = (int)(SWIG_As_int(obj1));
5773 if (SWIG_arg_fail(2)) SWIG_fail;
5774 }
5775 {
5776 arg3 = (int)(SWIG_As_int(obj2));
5777 if (SWIG_arg_fail(3)) SWIG_fail;
5778 }
5779 {
5780 PyThreadState* __tstate = wxPyBeginAllowThreads();
5781 {
5782 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5783 result = (wxRect *) &_result_ref;
5784 }
5785
5786 wxPyEndAllowThreads(__tstate);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5790 return resultobj;
5791 fail:
5792 return NULL;
5793 }
5794
5795
5796 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5797 PyObject *resultobj;
5798 wxRect *arg1 = (wxRect *) 0 ;
5799 int arg2 ;
5800 int arg3 ;
5801 PyObject * obj0 = 0 ;
5802 PyObject * obj1 = 0 ;
5803 PyObject * obj2 = 0 ;
5804 char *kwnames[] = {
5805 (char *) "self",(char *) "dx",(char *) "dy", NULL
5806 };
5807
5808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5810 if (SWIG_arg_fail(1)) SWIG_fail;
5811 {
5812 arg2 = (int)(SWIG_As_int(obj1));
5813 if (SWIG_arg_fail(2)) SWIG_fail;
5814 }
5815 {
5816 arg3 = (int)(SWIG_As_int(obj2));
5817 if (SWIG_arg_fail(3)) SWIG_fail;
5818 }
5819 {
5820 PyThreadState* __tstate = wxPyBeginAllowThreads();
5821 (arg1)->Offset(arg2,arg3);
5822
5823 wxPyEndAllowThreads(__tstate);
5824 if (PyErr_Occurred()) SWIG_fail;
5825 }
5826 Py_INCREF(Py_None); resultobj = Py_None;
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxRect *arg1 = (wxRect *) 0 ;
5836 wxPoint *arg2 = 0 ;
5837 wxPoint temp2 ;
5838 PyObject * obj0 = 0 ;
5839 PyObject * obj1 = 0 ;
5840 char *kwnames[] = {
5841 (char *) "self",(char *) "pt", NULL
5842 };
5843
5844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5846 if (SWIG_arg_fail(1)) SWIG_fail;
5847 {
5848 arg2 = &temp2;
5849 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5850 }
5851 {
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 (arg1)->Offset((wxPoint const &)*arg2);
5854
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 Py_INCREF(Py_None); resultobj = Py_None;
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxRect *arg1 = (wxRect *) 0 ;
5868 wxRect *arg2 = 0 ;
5869 wxRect result;
5870 wxRect temp2 ;
5871 PyObject * obj0 = 0 ;
5872 PyObject * obj1 = 0 ;
5873 char *kwnames[] = {
5874 (char *) "self",(char *) "rect", NULL
5875 };
5876
5877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5879 if (SWIG_arg_fail(1)) SWIG_fail;
5880 {
5881 arg2 = &temp2;
5882 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5883 }
5884 {
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 result = (arg1)->Intersect((wxRect const &)*arg2);
5887
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 {
5892 wxRect * resultptr;
5893 resultptr = new wxRect((wxRect &)(result));
5894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5895 }
5896 return resultobj;
5897 fail:
5898 return NULL;
5899 }
5900
5901
5902 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5903 PyObject *resultobj;
5904 wxRect *arg1 = (wxRect *) 0 ;
5905 wxRect *arg2 = 0 ;
5906 wxRect result;
5907 wxRect temp2 ;
5908 PyObject * obj0 = 0 ;
5909 PyObject * obj1 = 0 ;
5910 char *kwnames[] = {
5911 (char *) "self",(char *) "rect", NULL
5912 };
5913
5914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5916 if (SWIG_arg_fail(1)) SWIG_fail;
5917 {
5918 arg2 = &temp2;
5919 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5920 }
5921 {
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 result = (arg1)->Union((wxRect const &)*arg2);
5924
5925 wxPyEndAllowThreads(__tstate);
5926 if (PyErr_Occurred()) SWIG_fail;
5927 }
5928 {
5929 wxRect * resultptr;
5930 resultptr = new wxRect((wxRect &)(result));
5931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5932 }
5933 return resultobj;
5934 fail:
5935 return NULL;
5936 }
5937
5938
5939 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5940 PyObject *resultobj;
5941 wxRect *arg1 = (wxRect *) 0 ;
5942 wxRect *arg2 = 0 ;
5943 wxRect result;
5944 wxRect temp2 ;
5945 PyObject * obj0 = 0 ;
5946 PyObject * obj1 = 0 ;
5947 char *kwnames[] = {
5948 (char *) "self",(char *) "rect", NULL
5949 };
5950
5951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5953 if (SWIG_arg_fail(1)) SWIG_fail;
5954 {
5955 arg2 = &temp2;
5956 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5957 }
5958 {
5959 PyThreadState* __tstate = wxPyBeginAllowThreads();
5960 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5961
5962 wxPyEndAllowThreads(__tstate);
5963 if (PyErr_Occurred()) SWIG_fail;
5964 }
5965 {
5966 wxRect * resultptr;
5967 resultptr = new wxRect((wxRect &)(result));
5968 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5969 }
5970 return resultobj;
5971 fail:
5972 return NULL;
5973 }
5974
5975
5976 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5977 PyObject *resultobj;
5978 wxRect *arg1 = (wxRect *) 0 ;
5979 wxRect *arg2 = 0 ;
5980 wxRect *result;
5981 wxRect temp2 ;
5982 PyObject * obj0 = 0 ;
5983 PyObject * obj1 = 0 ;
5984 char *kwnames[] = {
5985 (char *) "self",(char *) "rect", NULL
5986 };
5987
5988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5990 if (SWIG_arg_fail(1)) SWIG_fail;
5991 {
5992 arg2 = &temp2;
5993 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5994 }
5995 {
5996 PyThreadState* __tstate = wxPyBeginAllowThreads();
5997 {
5998 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5999 result = (wxRect *) &_result_ref;
6000 }
6001
6002 wxPyEndAllowThreads(__tstate);
6003 if (PyErr_Occurred()) SWIG_fail;
6004 }
6005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6006 return resultobj;
6007 fail:
6008 return NULL;
6009 }
6010
6011
6012 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6013 PyObject *resultobj;
6014 wxRect *arg1 = (wxRect *) 0 ;
6015 wxRect *arg2 = 0 ;
6016 bool result;
6017 wxRect temp2 ;
6018 PyObject * obj0 = 0 ;
6019 PyObject * obj1 = 0 ;
6020 char *kwnames[] = {
6021 (char *) "self",(char *) "rect", NULL
6022 };
6023
6024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6026 if (SWIG_arg_fail(1)) SWIG_fail;
6027 {
6028 arg2 = &temp2;
6029 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6030 }
6031 {
6032 PyThreadState* __tstate = wxPyBeginAllowThreads();
6033 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6034
6035 wxPyEndAllowThreads(__tstate);
6036 if (PyErr_Occurred()) SWIG_fail;
6037 }
6038 {
6039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6040 }
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj;
6049 wxRect *arg1 = (wxRect *) 0 ;
6050 wxRect *arg2 = 0 ;
6051 bool result;
6052 wxRect temp2 ;
6053 PyObject * obj0 = 0 ;
6054 PyObject * obj1 = 0 ;
6055 char *kwnames[] = {
6056 (char *) "self",(char *) "rect", NULL
6057 };
6058
6059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6061 if (SWIG_arg_fail(1)) SWIG_fail;
6062 {
6063 arg2 = &temp2;
6064 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6065 }
6066 {
6067 PyThreadState* __tstate = wxPyBeginAllowThreads();
6068 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6069
6070 wxPyEndAllowThreads(__tstate);
6071 if (PyErr_Occurred()) SWIG_fail;
6072 }
6073 {
6074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6075 }
6076 return resultobj;
6077 fail:
6078 return NULL;
6079 }
6080
6081
6082 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6083 PyObject *resultobj;
6084 wxRect *arg1 = (wxRect *) 0 ;
6085 int arg2 ;
6086 int arg3 ;
6087 bool result;
6088 PyObject * obj0 = 0 ;
6089 PyObject * obj1 = 0 ;
6090 PyObject * obj2 = 0 ;
6091 char *kwnames[] = {
6092 (char *) "self",(char *) "x",(char *) "y", NULL
6093 };
6094
6095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6097 if (SWIG_arg_fail(1)) SWIG_fail;
6098 {
6099 arg2 = (int)(SWIG_As_int(obj1));
6100 if (SWIG_arg_fail(2)) SWIG_fail;
6101 }
6102 {
6103 arg3 = (int)(SWIG_As_int(obj2));
6104 if (SWIG_arg_fail(3)) SWIG_fail;
6105 }
6106 {
6107 PyThreadState* __tstate = wxPyBeginAllowThreads();
6108 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6109
6110 wxPyEndAllowThreads(__tstate);
6111 if (PyErr_Occurred()) SWIG_fail;
6112 }
6113 {
6114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6115 }
6116 return resultobj;
6117 fail:
6118 return NULL;
6119 }
6120
6121
6122 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6123 PyObject *resultobj;
6124 wxRect *arg1 = (wxRect *) 0 ;
6125 wxPoint *arg2 = 0 ;
6126 bool result;
6127 wxPoint temp2 ;
6128 PyObject * obj0 = 0 ;
6129 PyObject * obj1 = 0 ;
6130 char *kwnames[] = {
6131 (char *) "self",(char *) "pt", NULL
6132 };
6133
6134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6136 if (SWIG_arg_fail(1)) SWIG_fail;
6137 {
6138 arg2 = &temp2;
6139 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6140 }
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6144
6145 wxPyEndAllowThreads(__tstate);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 {
6149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6150 }
6151 return resultobj;
6152 fail:
6153 return NULL;
6154 }
6155
6156
6157 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6158 PyObject *resultobj;
6159 wxRect *arg1 = (wxRect *) 0 ;
6160 wxRect *arg2 = 0 ;
6161 bool result;
6162 wxRect temp2 ;
6163 PyObject * obj0 = 0 ;
6164 PyObject * obj1 = 0 ;
6165 char *kwnames[] = {
6166 (char *) "self",(char *) "rect", NULL
6167 };
6168
6169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6171 if (SWIG_arg_fail(1)) SWIG_fail;
6172 {
6173 arg2 = &temp2;
6174 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6175 }
6176 {
6177 PyThreadState* __tstate = wxPyBeginAllowThreads();
6178 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6179
6180 wxPyEndAllowThreads(__tstate);
6181 if (PyErr_Occurred()) SWIG_fail;
6182 }
6183 {
6184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6185 }
6186 return resultobj;
6187 fail:
6188 return NULL;
6189 }
6190
6191
6192 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6193 PyObject *resultobj;
6194 wxRect *arg1 = (wxRect *) 0 ;
6195 int arg2 ;
6196 PyObject * obj0 = 0 ;
6197 PyObject * obj1 = 0 ;
6198 char *kwnames[] = {
6199 (char *) "self",(char *) "x", NULL
6200 };
6201
6202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6204 if (SWIG_arg_fail(1)) SWIG_fail;
6205 {
6206 arg2 = (int)(SWIG_As_int(obj1));
6207 if (SWIG_arg_fail(2)) SWIG_fail;
6208 }
6209 if (arg1) (arg1)->x = arg2;
6210
6211 Py_INCREF(Py_None); resultobj = Py_None;
6212 return resultobj;
6213 fail:
6214 return NULL;
6215 }
6216
6217
6218 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6219 PyObject *resultobj;
6220 wxRect *arg1 = (wxRect *) 0 ;
6221 int result;
6222 PyObject * obj0 = 0 ;
6223 char *kwnames[] = {
6224 (char *) "self", NULL
6225 };
6226
6227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6229 if (SWIG_arg_fail(1)) SWIG_fail;
6230 result = (int) ((arg1)->x);
6231
6232 {
6233 resultobj = SWIG_From_int((int)(result));
6234 }
6235 return resultobj;
6236 fail:
6237 return NULL;
6238 }
6239
6240
6241 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6242 PyObject *resultobj;
6243 wxRect *arg1 = (wxRect *) 0 ;
6244 int arg2 ;
6245 PyObject * obj0 = 0 ;
6246 PyObject * obj1 = 0 ;
6247 char *kwnames[] = {
6248 (char *) "self",(char *) "y", NULL
6249 };
6250
6251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6253 if (SWIG_arg_fail(1)) SWIG_fail;
6254 {
6255 arg2 = (int)(SWIG_As_int(obj1));
6256 if (SWIG_arg_fail(2)) SWIG_fail;
6257 }
6258 if (arg1) (arg1)->y = arg2;
6259
6260 Py_INCREF(Py_None); resultobj = Py_None;
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int result;
6271 PyObject * obj0 = 0 ;
6272 char *kwnames[] = {
6273 (char *) "self", NULL
6274 };
6275
6276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6278 if (SWIG_arg_fail(1)) SWIG_fail;
6279 result = (int) ((arg1)->y);
6280
6281 {
6282 resultobj = SWIG_From_int((int)(result));
6283 }
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 int arg2 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 char *kwnames[] = {
6297 (char *) "self",(char *) "width", NULL
6298 };
6299
6300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6302 if (SWIG_arg_fail(1)) SWIG_fail;
6303 {
6304 arg2 = (int)(SWIG_As_int(obj1));
6305 if (SWIG_arg_fail(2)) SWIG_fail;
6306 }
6307 if (arg1) (arg1)->width = arg2;
6308
6309 Py_INCREF(Py_None); resultobj = Py_None;
6310 return resultobj;
6311 fail:
6312 return NULL;
6313 }
6314
6315
6316 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6317 PyObject *resultobj;
6318 wxRect *arg1 = (wxRect *) 0 ;
6319 int result;
6320 PyObject * obj0 = 0 ;
6321 char *kwnames[] = {
6322 (char *) "self", NULL
6323 };
6324
6325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6327 if (SWIG_arg_fail(1)) SWIG_fail;
6328 result = (int) ((arg1)->width);
6329
6330 {
6331 resultobj = SWIG_From_int((int)(result));
6332 }
6333 return resultobj;
6334 fail:
6335 return NULL;
6336 }
6337
6338
6339 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6340 PyObject *resultobj;
6341 wxRect *arg1 = (wxRect *) 0 ;
6342 int arg2 ;
6343 PyObject * obj0 = 0 ;
6344 PyObject * obj1 = 0 ;
6345 char *kwnames[] = {
6346 (char *) "self",(char *) "height", NULL
6347 };
6348
6349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6351 if (SWIG_arg_fail(1)) SWIG_fail;
6352 {
6353 arg2 = (int)(SWIG_As_int(obj1));
6354 if (SWIG_arg_fail(2)) SWIG_fail;
6355 }
6356 if (arg1) (arg1)->height = arg2;
6357
6358 Py_INCREF(Py_None); resultobj = Py_None;
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6366 PyObject *resultobj;
6367 wxRect *arg1 = (wxRect *) 0 ;
6368 int result;
6369 PyObject * obj0 = 0 ;
6370 char *kwnames[] = {
6371 (char *) "self", NULL
6372 };
6373
6374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6376 if (SWIG_arg_fail(1)) SWIG_fail;
6377 result = (int) ((arg1)->height);
6378
6379 {
6380 resultobj = SWIG_From_int((int)(result));
6381 }
6382 return resultobj;
6383 fail:
6384 return NULL;
6385 }
6386
6387
6388 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6389 PyObject *resultobj;
6390 wxRect *arg1 = (wxRect *) 0 ;
6391 int arg2 = (int) 0 ;
6392 int arg3 = (int) 0 ;
6393 int arg4 = (int) 0 ;
6394 int arg5 = (int) 0 ;
6395 PyObject * obj0 = 0 ;
6396 PyObject * obj1 = 0 ;
6397 PyObject * obj2 = 0 ;
6398 PyObject * obj3 = 0 ;
6399 PyObject * obj4 = 0 ;
6400 char *kwnames[] = {
6401 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6402 };
6403
6404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6406 if (SWIG_arg_fail(1)) SWIG_fail;
6407 if (obj1) {
6408 {
6409 arg2 = (int)(SWIG_As_int(obj1));
6410 if (SWIG_arg_fail(2)) SWIG_fail;
6411 }
6412 }
6413 if (obj2) {
6414 {
6415 arg3 = (int)(SWIG_As_int(obj2));
6416 if (SWIG_arg_fail(3)) SWIG_fail;
6417 }
6418 }
6419 if (obj3) {
6420 {
6421 arg4 = (int)(SWIG_As_int(obj3));
6422 if (SWIG_arg_fail(4)) SWIG_fail;
6423 }
6424 }
6425 if (obj4) {
6426 {
6427 arg5 = (int)(SWIG_As_int(obj4));
6428 if (SWIG_arg_fail(5)) SWIG_fail;
6429 }
6430 }
6431 {
6432 PyThreadState* __tstate = wxPyBeginAllowThreads();
6433 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6434
6435 wxPyEndAllowThreads(__tstate);
6436 if (PyErr_Occurred()) SWIG_fail;
6437 }
6438 Py_INCREF(Py_None); resultobj = Py_None;
6439 return resultobj;
6440 fail:
6441 return NULL;
6442 }
6443
6444
6445 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6446 PyObject *resultobj;
6447 wxRect *arg1 = (wxRect *) 0 ;
6448 PyObject *result;
6449 PyObject * obj0 = 0 ;
6450 char *kwnames[] = {
6451 (char *) "self", NULL
6452 };
6453
6454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6456 if (SWIG_arg_fail(1)) SWIG_fail;
6457 {
6458 PyThreadState* __tstate = wxPyBeginAllowThreads();
6459 result = (PyObject *)wxRect_Get(arg1);
6460
6461 wxPyEndAllowThreads(__tstate);
6462 if (PyErr_Occurred()) SWIG_fail;
6463 }
6464 resultobj = result;
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6472 PyObject *obj;
6473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6474 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6475 Py_INCREF(obj);
6476 return Py_BuildValue((char *)"");
6477 }
6478 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6479 PyObject *resultobj;
6480 wxRect *arg1 = (wxRect *) 0 ;
6481 wxRect *arg2 = (wxRect *) 0 ;
6482 PyObject *result;
6483 PyObject * obj0 = 0 ;
6484 PyObject * obj1 = 0 ;
6485 char *kwnames[] = {
6486 (char *) "r1",(char *) "r2", NULL
6487 };
6488
6489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6491 if (SWIG_arg_fail(1)) SWIG_fail;
6492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6493 if (SWIG_arg_fail(2)) SWIG_fail;
6494 {
6495 if (!wxPyCheckForApp()) SWIG_fail;
6496 PyThreadState* __tstate = wxPyBeginAllowThreads();
6497 result = (PyObject *)wxIntersectRect(arg1,arg2);
6498
6499 wxPyEndAllowThreads(__tstate);
6500 if (PyErr_Occurred()) SWIG_fail;
6501 }
6502 resultobj = result;
6503 return resultobj;
6504 fail:
6505 return NULL;
6506 }
6507
6508
6509 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6510 PyObject *resultobj;
6511 double arg1 = (double) 0.0 ;
6512 double arg2 = (double) 0.0 ;
6513 wxPoint2D *result;
6514 PyObject * obj0 = 0 ;
6515 PyObject * obj1 = 0 ;
6516 char *kwnames[] = {
6517 (char *) "x",(char *) "y", NULL
6518 };
6519
6520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6521 if (obj0) {
6522 {
6523 arg1 = (double)(SWIG_As_double(obj0));
6524 if (SWIG_arg_fail(1)) SWIG_fail;
6525 }
6526 }
6527 if (obj1) {
6528 {
6529 arg2 = (double)(SWIG_As_double(obj1));
6530 if (SWIG_arg_fail(2)) SWIG_fail;
6531 }
6532 }
6533 {
6534 PyThreadState* __tstate = wxPyBeginAllowThreads();
6535 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6536
6537 wxPyEndAllowThreads(__tstate);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj;
6549 wxPoint2D *arg1 = 0 ;
6550 wxPoint2D *result;
6551 wxPoint2D temp1 ;
6552 PyObject * obj0 = 0 ;
6553 char *kwnames[] = {
6554 (char *) "pt", NULL
6555 };
6556
6557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6558 {
6559 arg1 = &temp1;
6560 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6561 }
6562 {
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6565
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6570 return resultobj;
6571 fail:
6572 return NULL;
6573 }
6574
6575
6576 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6577 PyObject *resultobj;
6578 wxPoint *arg1 = 0 ;
6579 wxPoint2D *result;
6580 wxPoint temp1 ;
6581 PyObject * obj0 = 0 ;
6582 char *kwnames[] = {
6583 (char *) "pt", NULL
6584 };
6585
6586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6587 {
6588 arg1 = &temp1;
6589 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6590 }
6591 {
6592 PyThreadState* __tstate = wxPyBeginAllowThreads();
6593 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6594
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6606 PyObject *resultobj;
6607 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6608 int *arg2 = (int *) 0 ;
6609 int *arg3 = (int *) 0 ;
6610 int temp2 ;
6611 int res2 = 0 ;
6612 int temp3 ;
6613 int res3 = 0 ;
6614 PyObject * obj0 = 0 ;
6615 char *kwnames[] = {
6616 (char *) "self", NULL
6617 };
6618
6619 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6620 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6623 if (SWIG_arg_fail(1)) SWIG_fail;
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6627
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 Py_INCREF(Py_None); resultobj = Py_None;
6632 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6633 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6634 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6635 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6643 PyObject *resultobj;
6644 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6645 int *arg2 = (int *) 0 ;
6646 int *arg3 = (int *) 0 ;
6647 int temp2 ;
6648 int res2 = 0 ;
6649 int temp3 ;
6650 int res3 = 0 ;
6651 PyObject * obj0 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self", NULL
6654 };
6655
6656 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6657 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6660 if (SWIG_arg_fail(1)) SWIG_fail;
6661 {
6662 PyThreadState* __tstate = wxPyBeginAllowThreads();
6663 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6664
6665 wxPyEndAllowThreads(__tstate);
6666 if (PyErr_Occurred()) SWIG_fail;
6667 }
6668 Py_INCREF(Py_None); resultobj = Py_None;
6669 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6670 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6671 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6672 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj;
6681 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6682 double result;
6683 PyObject * obj0 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "self", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6690 if (SWIG_arg_fail(1)) SWIG_fail;
6691 {
6692 PyThreadState* __tstate = wxPyBeginAllowThreads();
6693 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6694
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 {
6699 resultobj = SWIG_From_double((double)(result));
6700 }
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj;
6709 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6710 double result;
6711 PyObject * obj0 = 0 ;
6712 char *kwnames[] = {
6713 (char *) "self", NULL
6714 };
6715
6716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6718 if (SWIG_arg_fail(1)) SWIG_fail;
6719 {
6720 PyThreadState* __tstate = wxPyBeginAllowThreads();
6721 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6722
6723 wxPyEndAllowThreads(__tstate);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 {
6727 resultobj = SWIG_From_double((double)(result));
6728 }
6729 return resultobj;
6730 fail:
6731 return NULL;
6732 }
6733
6734
6735 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6736 PyObject *resultobj;
6737 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6738 double arg2 ;
6739 PyObject * obj0 = 0 ;
6740 PyObject * obj1 = 0 ;
6741 char *kwnames[] = {
6742 (char *) "self",(char *) "length", NULL
6743 };
6744
6745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6747 if (SWIG_arg_fail(1)) SWIG_fail;
6748 {
6749 arg2 = (double)(SWIG_As_double(obj1));
6750 if (SWIG_arg_fail(2)) SWIG_fail;
6751 }
6752 {
6753 PyThreadState* __tstate = wxPyBeginAllowThreads();
6754 (arg1)->SetVectorLength(arg2);
6755
6756 wxPyEndAllowThreads(__tstate);
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 Py_INCREF(Py_None); resultobj = Py_None;
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6767 PyObject *resultobj;
6768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6769 double arg2 ;
6770 PyObject * obj0 = 0 ;
6771 PyObject * obj1 = 0 ;
6772 char *kwnames[] = {
6773 (char *) "self",(char *) "degrees", NULL
6774 };
6775
6776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6778 if (SWIG_arg_fail(1)) SWIG_fail;
6779 {
6780 arg2 = (double)(SWIG_As_double(obj1));
6781 if (SWIG_arg_fail(2)) SWIG_fail;
6782 }
6783 {
6784 PyThreadState* __tstate = wxPyBeginAllowThreads();
6785 (arg1)->SetVectorAngle(arg2);
6786
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 Py_INCREF(Py_None); resultobj = Py_None;
6791 return resultobj;
6792 fail:
6793 return NULL;
6794 }
6795
6796
6797 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6798 PyObject *resultobj;
6799 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6800 wxPoint2D *arg2 = 0 ;
6801 double result;
6802 wxPoint2D temp2 ;
6803 PyObject * obj0 = 0 ;
6804 PyObject * obj1 = 0 ;
6805 char *kwnames[] = {
6806 (char *) "self",(char *) "pt", NULL
6807 };
6808
6809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6811 if (SWIG_arg_fail(1)) SWIG_fail;
6812 {
6813 arg2 = &temp2;
6814 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6815 }
6816 {
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6819
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 {
6824 resultobj = SWIG_From_double((double)(result));
6825 }
6826 return resultobj;
6827 fail:
6828 return NULL;
6829 }
6830
6831
6832 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6833 PyObject *resultobj;
6834 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6835 wxPoint2D *arg2 = 0 ;
6836 double result;
6837 wxPoint2D temp2 ;
6838 PyObject * obj0 = 0 ;
6839 PyObject * obj1 = 0 ;
6840 char *kwnames[] = {
6841 (char *) "self",(char *) "pt", NULL
6842 };
6843
6844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6846 if (SWIG_arg_fail(1)) SWIG_fail;
6847 {
6848 arg2 = &temp2;
6849 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6850 }
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6854
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 {
6859 resultobj = SWIG_From_double((double)(result));
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6868 PyObject *resultobj;
6869 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6870 wxPoint2D *arg2 = 0 ;
6871 double result;
6872 wxPoint2D temp2 ;
6873 PyObject * obj0 = 0 ;
6874 PyObject * obj1 = 0 ;
6875 char *kwnames[] = {
6876 (char *) "self",(char *) "vec", NULL
6877 };
6878
6879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6881 if (SWIG_arg_fail(1)) SWIG_fail;
6882 {
6883 arg2 = &temp2;
6884 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6885 }
6886 {
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6889
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 {
6894 resultobj = SWIG_From_double((double)(result));
6895 }
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6905 wxPoint2D *arg2 = 0 ;
6906 double result;
6907 wxPoint2D temp2 ;
6908 PyObject * obj0 = 0 ;
6909 PyObject * obj1 = 0 ;
6910 char *kwnames[] = {
6911 (char *) "self",(char *) "vec", NULL
6912 };
6913
6914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6916 if (SWIG_arg_fail(1)) SWIG_fail;
6917 {
6918 arg2 = &temp2;
6919 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6920 }
6921 {
6922 PyThreadState* __tstate = wxPyBeginAllowThreads();
6923 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6924
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 {
6929 resultobj = SWIG_From_double((double)(result));
6930 }
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6938 PyObject *resultobj;
6939 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6940 wxPoint2D result;
6941 PyObject * obj0 = 0 ;
6942 char *kwnames[] = {
6943 (char *) "self", NULL
6944 };
6945
6946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6948 if (SWIG_arg_fail(1)) SWIG_fail;
6949 {
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 result = (arg1)->operator -();
6952
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 {
6957 wxPoint2D * resultptr;
6958 resultptr = new wxPoint2D((wxPoint2D &)(result));
6959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6960 }
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6968 PyObject *resultobj;
6969 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6970 wxPoint2D *arg2 = 0 ;
6971 wxPoint2D *result;
6972 wxPoint2D temp2 ;
6973 PyObject * obj0 = 0 ;
6974 PyObject * obj1 = 0 ;
6975 char *kwnames[] = {
6976 (char *) "self",(char *) "pt", NULL
6977 };
6978
6979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6981 if (SWIG_arg_fail(1)) SWIG_fail;
6982 {
6983 arg2 = &temp2;
6984 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6985 }
6986 {
6987 PyThreadState* __tstate = wxPyBeginAllowThreads();
6988 {
6989 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6990 result = (wxPoint2D *) &_result_ref;
6991 }
6992
6993 wxPyEndAllowThreads(__tstate);
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7004 PyObject *resultobj;
7005 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7006 wxPoint2D *arg2 = 0 ;
7007 wxPoint2D *result;
7008 wxPoint2D temp2 ;
7009 PyObject * obj0 = 0 ;
7010 PyObject * obj1 = 0 ;
7011 char *kwnames[] = {
7012 (char *) "self",(char *) "pt", NULL
7013 };
7014
7015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7017 if (SWIG_arg_fail(1)) SWIG_fail;
7018 {
7019 arg2 = &temp2;
7020 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7021 }
7022 {
7023 PyThreadState* __tstate = wxPyBeginAllowThreads();
7024 {
7025 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7026 result = (wxPoint2D *) &_result_ref;
7027 }
7028
7029 wxPyEndAllowThreads(__tstate);
7030 if (PyErr_Occurred()) SWIG_fail;
7031 }
7032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7033 return resultobj;
7034 fail:
7035 return NULL;
7036 }
7037
7038
7039 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7040 PyObject *resultobj;
7041 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7042 wxPoint2D *arg2 = 0 ;
7043 wxPoint2D *result;
7044 wxPoint2D temp2 ;
7045 PyObject * obj0 = 0 ;
7046 PyObject * obj1 = 0 ;
7047 char *kwnames[] = {
7048 (char *) "self",(char *) "pt", NULL
7049 };
7050
7051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7053 if (SWIG_arg_fail(1)) SWIG_fail;
7054 {
7055 arg2 = &temp2;
7056 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7057 }
7058 {
7059 PyThreadState* __tstate = wxPyBeginAllowThreads();
7060 {
7061 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7062 result = (wxPoint2D *) &_result_ref;
7063 }
7064
7065 wxPyEndAllowThreads(__tstate);
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7076 PyObject *resultobj;
7077 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7078 wxPoint2D *arg2 = 0 ;
7079 wxPoint2D *result;
7080 wxPoint2D temp2 ;
7081 PyObject * obj0 = 0 ;
7082 PyObject * obj1 = 0 ;
7083 char *kwnames[] = {
7084 (char *) "self",(char *) "pt", NULL
7085 };
7086
7087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7089 if (SWIG_arg_fail(1)) SWIG_fail;
7090 {
7091 arg2 = &temp2;
7092 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7093 }
7094 {
7095 PyThreadState* __tstate = wxPyBeginAllowThreads();
7096 {
7097 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7098 result = (wxPoint2D *) &_result_ref;
7099 }
7100
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7112 PyObject *resultobj;
7113 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7114 wxPoint2D *arg2 = 0 ;
7115 bool result;
7116 wxPoint2D temp2 ;
7117 PyObject * obj0 = 0 ;
7118 PyObject * obj1 = 0 ;
7119 char *kwnames[] = {
7120 (char *) "self",(char *) "pt", NULL
7121 };
7122
7123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7125 if (SWIG_arg_fail(1)) SWIG_fail;
7126 {
7127 arg2 = &temp2;
7128 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7129 }
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7133
7134 wxPyEndAllowThreads(__tstate);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 {
7138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7139 }
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj;
7148 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7149 wxPoint2D *arg2 = 0 ;
7150 bool result;
7151 wxPoint2D temp2 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char *kwnames[] = {
7155 (char *) "self",(char *) "pt", NULL
7156 };
7157
7158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7160 if (SWIG_arg_fail(1)) SWIG_fail;
7161 {
7162 arg2 = &temp2;
7163 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7164 }
7165 {
7166 PyThreadState* __tstate = wxPyBeginAllowThreads();
7167 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7168
7169 wxPyEndAllowThreads(__tstate);
7170 if (PyErr_Occurred()) SWIG_fail;
7171 }
7172 {
7173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7174 }
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7182 PyObject *resultobj;
7183 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7184 double arg2 ;
7185 PyObject * obj0 = 0 ;
7186 PyObject * obj1 = 0 ;
7187 char *kwnames[] = {
7188 (char *) "self",(char *) "m_x", NULL
7189 };
7190
7191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7193 if (SWIG_arg_fail(1)) SWIG_fail;
7194 {
7195 arg2 = (double)(SWIG_As_double(obj1));
7196 if (SWIG_arg_fail(2)) SWIG_fail;
7197 }
7198 if (arg1) (arg1)->m_x = arg2;
7199
7200 Py_INCREF(Py_None); resultobj = Py_None;
7201 return resultobj;
7202 fail:
7203 return NULL;
7204 }
7205
7206
7207 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7208 PyObject *resultobj;
7209 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7210 double result;
7211 PyObject * obj0 = 0 ;
7212 char *kwnames[] = {
7213 (char *) "self", NULL
7214 };
7215
7216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7218 if (SWIG_arg_fail(1)) SWIG_fail;
7219 result = (double) ((arg1)->m_x);
7220
7221 {
7222 resultobj = SWIG_From_double((double)(result));
7223 }
7224 return resultobj;
7225 fail:
7226 return NULL;
7227 }
7228
7229
7230 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7231 PyObject *resultobj;
7232 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7233 double arg2 ;
7234 PyObject * obj0 = 0 ;
7235 PyObject * obj1 = 0 ;
7236 char *kwnames[] = {
7237 (char *) "self",(char *) "m_y", NULL
7238 };
7239
7240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7242 if (SWIG_arg_fail(1)) SWIG_fail;
7243 {
7244 arg2 = (double)(SWIG_As_double(obj1));
7245 if (SWIG_arg_fail(2)) SWIG_fail;
7246 }
7247 if (arg1) (arg1)->m_y = arg2;
7248
7249 Py_INCREF(Py_None); resultobj = Py_None;
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj;
7258 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7259 double result;
7260 PyObject * obj0 = 0 ;
7261 char *kwnames[] = {
7262 (char *) "self", NULL
7263 };
7264
7265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7267 if (SWIG_arg_fail(1)) SWIG_fail;
7268 result = (double) ((arg1)->m_y);
7269
7270 {
7271 resultobj = SWIG_From_double((double)(result));
7272 }
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj;
7281 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7282 double arg2 = (double) 0 ;
7283 double arg3 = (double) 0 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 PyObject * obj2 = 0 ;
7287 char *kwnames[] = {
7288 (char *) "self",(char *) "x",(char *) "y", NULL
7289 };
7290
7291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7293 if (SWIG_arg_fail(1)) SWIG_fail;
7294 if (obj1) {
7295 {
7296 arg2 = (double)(SWIG_As_double(obj1));
7297 if (SWIG_arg_fail(2)) SWIG_fail;
7298 }
7299 }
7300 if (obj2) {
7301 {
7302 arg3 = (double)(SWIG_As_double(obj2));
7303 if (SWIG_arg_fail(3)) SWIG_fail;
7304 }
7305 }
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 wxPoint2D_Set(arg1,arg2,arg3);
7309
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 Py_INCREF(Py_None); resultobj = Py_None;
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj;
7322 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7323 PyObject *result;
7324 PyObject * obj0 = 0 ;
7325 char *kwnames[] = {
7326 (char *) "self", NULL
7327 };
7328
7329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7331 if (SWIG_arg_fail(1)) SWIG_fail;
7332 {
7333 PyThreadState* __tstate = wxPyBeginAllowThreads();
7334 result = (PyObject *)wxPoint2D_Get(arg1);
7335
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = result;
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7347 PyObject *obj;
7348 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7349 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7350 Py_INCREF(obj);
7351 return Py_BuildValue((char *)"");
7352 }
7353 static int _wrap_DefaultPosition_set(PyObject *) {
7354 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7355 return 1;
7356 }
7357
7358
7359 static PyObject *_wrap_DefaultPosition_get(void) {
7360 PyObject *pyobj;
7361
7362 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7363 return pyobj;
7364 }
7365
7366
7367 static int _wrap_DefaultSize_set(PyObject *) {
7368 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7369 return 1;
7370 }
7371
7372
7373 static PyObject *_wrap_DefaultSize_get(void) {
7374 PyObject *pyobj;
7375
7376 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7377 return pyobj;
7378 }
7379
7380
7381 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7382 PyObject *resultobj;
7383 PyObject *arg1 = (PyObject *) 0 ;
7384 wxPyInputStream *result;
7385 PyObject * obj0 = 0 ;
7386 char *kwnames[] = {
7387 (char *) "p", NULL
7388 };
7389
7390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7391 arg1 = obj0;
7392 {
7393 PyThreadState* __tstate = wxPyBeginAllowThreads();
7394 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7395
7396 wxPyEndAllowThreads(__tstate);
7397 if (PyErr_Occurred()) SWIG_fail;
7398 }
7399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7407 PyObject *resultobj;
7408 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7409 PyObject * obj0 = 0 ;
7410 char *kwnames[] = {
7411 (char *) "self", NULL
7412 };
7413
7414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",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 delete arg1;
7420
7421 wxPyEndAllowThreads(__tstate);
7422 if (PyErr_Occurred()) SWIG_fail;
7423 }
7424 Py_INCREF(Py_None); resultobj = Py_None;
7425 return resultobj;
7426 fail:
7427 return NULL;
7428 }
7429
7430
7431 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7432 PyObject *resultobj;
7433 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7434 PyObject * obj0 = 0 ;
7435 char *kwnames[] = {
7436 (char *) "self", NULL
7437 };
7438
7439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7441 if (SWIG_arg_fail(1)) SWIG_fail;
7442 {
7443 PyThreadState* __tstate = wxPyBeginAllowThreads();
7444 (arg1)->close();
7445
7446 wxPyEndAllowThreads(__tstate);
7447 if (PyErr_Occurred()) SWIG_fail;
7448 }
7449 Py_INCREF(Py_None); resultobj = Py_None;
7450 return resultobj;
7451 fail:
7452 return NULL;
7453 }
7454
7455
7456 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7457 PyObject *resultobj;
7458 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7459 PyObject * obj0 = 0 ;
7460 char *kwnames[] = {
7461 (char *) "self", NULL
7462 };
7463
7464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7466 if (SWIG_arg_fail(1)) SWIG_fail;
7467 {
7468 PyThreadState* __tstate = wxPyBeginAllowThreads();
7469 (arg1)->flush();
7470
7471 wxPyEndAllowThreads(__tstate);
7472 if (PyErr_Occurred()) SWIG_fail;
7473 }
7474 Py_INCREF(Py_None); resultobj = Py_None;
7475 return resultobj;
7476 fail:
7477 return NULL;
7478 }
7479
7480
7481 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7482 PyObject *resultobj;
7483 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7484 bool result;
7485 PyObject * obj0 = 0 ;
7486 char *kwnames[] = {
7487 (char *) "self", NULL
7488 };
7489
7490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7492 if (SWIG_arg_fail(1)) SWIG_fail;
7493 {
7494 PyThreadState* __tstate = wxPyBeginAllowThreads();
7495 result = (bool)(arg1)->eof();
7496
7497 wxPyEndAllowThreads(__tstate);
7498 if (PyErr_Occurred()) SWIG_fail;
7499 }
7500 {
7501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7502 }
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj;
7511 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7512 int arg2 = (int) -1 ;
7513 PyObject *result;
7514 PyObject * obj0 = 0 ;
7515 PyObject * obj1 = 0 ;
7516 char *kwnames[] = {
7517 (char *) "self",(char *) "size", NULL
7518 };
7519
7520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7522 if (SWIG_arg_fail(1)) SWIG_fail;
7523 if (obj1) {
7524 {
7525 arg2 = (int)(SWIG_As_int(obj1));
7526 if (SWIG_arg_fail(2)) SWIG_fail;
7527 }
7528 }
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (PyObject *)(arg1)->read(arg2);
7532
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 resultobj = result;
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj;
7545 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7546 int arg2 = (int) -1 ;
7547 PyObject *result;
7548 PyObject * obj0 = 0 ;
7549 PyObject * obj1 = 0 ;
7550 char *kwnames[] = {
7551 (char *) "self",(char *) "size", NULL
7552 };
7553
7554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7556 if (SWIG_arg_fail(1)) SWIG_fail;
7557 if (obj1) {
7558 {
7559 arg2 = (int)(SWIG_As_int(obj1));
7560 if (SWIG_arg_fail(2)) SWIG_fail;
7561 }
7562 }
7563 {
7564 PyThreadState* __tstate = wxPyBeginAllowThreads();
7565 result = (PyObject *)(arg1)->readline(arg2);
7566
7567 wxPyEndAllowThreads(__tstate);
7568 if (PyErr_Occurred()) SWIG_fail;
7569 }
7570 resultobj = result;
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj;
7579 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7580 int arg2 = (int) -1 ;
7581 PyObject *result;
7582 PyObject * obj0 = 0 ;
7583 PyObject * obj1 = 0 ;
7584 char *kwnames[] = {
7585 (char *) "self",(char *) "sizehint", NULL
7586 };
7587
7588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7590 if (SWIG_arg_fail(1)) SWIG_fail;
7591 if (obj1) {
7592 {
7593 arg2 = (int)(SWIG_As_int(obj1));
7594 if (SWIG_arg_fail(2)) SWIG_fail;
7595 }
7596 }
7597 {
7598 PyThreadState* __tstate = wxPyBeginAllowThreads();
7599 result = (PyObject *)(arg1)->readlines(arg2);
7600
7601 wxPyEndAllowThreads(__tstate);
7602 if (PyErr_Occurred()) SWIG_fail;
7603 }
7604 resultobj = result;
7605 return resultobj;
7606 fail:
7607 return NULL;
7608 }
7609
7610
7611 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7612 PyObject *resultobj;
7613 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7614 int arg2 ;
7615 int arg3 = (int) 0 ;
7616 PyObject * obj0 = 0 ;
7617 PyObject * obj1 = 0 ;
7618 PyObject * obj2 = 0 ;
7619 char *kwnames[] = {
7620 (char *) "self",(char *) "offset",(char *) "whence", NULL
7621 };
7622
7623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7625 if (SWIG_arg_fail(1)) SWIG_fail;
7626 {
7627 arg2 = (int)(SWIG_As_int(obj1));
7628 if (SWIG_arg_fail(2)) SWIG_fail;
7629 }
7630 if (obj2) {
7631 {
7632 arg3 = (int)(SWIG_As_int(obj2));
7633 if (SWIG_arg_fail(3)) SWIG_fail;
7634 }
7635 }
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 (arg1)->seek(arg2,arg3);
7639
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 Py_INCREF(Py_None); resultobj = Py_None;
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj;
7652 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7653 int result;
7654 PyObject * obj0 = 0 ;
7655 char *kwnames[] = {
7656 (char *) "self", NULL
7657 };
7658
7659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7661 if (SWIG_arg_fail(1)) SWIG_fail;
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 result = (int)(arg1)->tell();
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 {
7670 resultobj = SWIG_From_int((int)(result));
7671 }
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7681 char result;
7682 PyObject * obj0 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7689 if (SWIG_arg_fail(1)) SWIG_fail;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (char)(arg1)->Peek();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = SWIG_From_char((char)(result));
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7709 char result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7717 if (SWIG_arg_fail(1)) SWIG_fail;
7718 {
7719 PyThreadState* __tstate = wxPyBeginAllowThreads();
7720 result = (char)(arg1)->GetC();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = SWIG_From_char((char)(result));
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7737 size_t result;
7738 PyObject * obj0 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (size_t)(arg1)->LastRead();
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 {
7754 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7755 }
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj;
7764 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7765 bool result;
7766 PyObject * obj0 = 0 ;
7767 char *kwnames[] = {
7768 (char *) "self", NULL
7769 };
7770
7771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7773 if (SWIG_arg_fail(1)) SWIG_fail;
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (bool)(arg1)->CanRead();
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 {
7782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7783 }
7784 return resultobj;
7785 fail:
7786 return NULL;
7787 }
7788
7789
7790 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj;
7792 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7793 bool result;
7794 PyObject * obj0 = 0 ;
7795 char *kwnames[] = {
7796 (char *) "self", NULL
7797 };
7798
7799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7801 if (SWIG_arg_fail(1)) SWIG_fail;
7802 {
7803 PyThreadState* __tstate = wxPyBeginAllowThreads();
7804 result = (bool)(arg1)->Eof();
7805
7806 wxPyEndAllowThreads(__tstate);
7807 if (PyErr_Occurred()) SWIG_fail;
7808 }
7809 {
7810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7811 }
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7819 PyObject *resultobj;
7820 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7821 char arg2 ;
7822 bool result;
7823 PyObject * obj0 = 0 ;
7824 PyObject * obj1 = 0 ;
7825 char *kwnames[] = {
7826 (char *) "self",(char *) "c", NULL
7827 };
7828
7829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7831 if (SWIG_arg_fail(1)) SWIG_fail;
7832 {
7833 arg2 = (char)(SWIG_As_char(obj1));
7834 if (SWIG_arg_fail(2)) SWIG_fail;
7835 }
7836 {
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 result = (bool)(arg1)->Ungetch(arg2);
7839
7840 wxPyEndAllowThreads(__tstate);
7841 if (PyErr_Occurred()) SWIG_fail;
7842 }
7843 {
7844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7845 }
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj;
7854 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7855 long arg2 ;
7856 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7857 long result;
7858 PyObject * obj0 = 0 ;
7859 PyObject * obj1 = 0 ;
7860 PyObject * obj2 = 0 ;
7861 char *kwnames[] = {
7862 (char *) "self",(char *) "pos",(char *) "mode", NULL
7863 };
7864
7865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7867 if (SWIG_arg_fail(1)) SWIG_fail;
7868 {
7869 arg2 = (long)(SWIG_As_long(obj1));
7870 if (SWIG_arg_fail(2)) SWIG_fail;
7871 }
7872 if (obj2) {
7873 {
7874 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7875 if (SWIG_arg_fail(3)) SWIG_fail;
7876 }
7877 }
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7881
7882 wxPyEndAllowThreads(__tstate);
7883 if (PyErr_Occurred()) SWIG_fail;
7884 }
7885 {
7886 resultobj = SWIG_From_long((long)(result));
7887 }
7888 return resultobj;
7889 fail:
7890 return NULL;
7891 }
7892
7893
7894 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7895 PyObject *resultobj;
7896 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7897 long result;
7898 PyObject * obj0 = 0 ;
7899 char *kwnames[] = {
7900 (char *) "self", NULL
7901 };
7902
7903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7905 if (SWIG_arg_fail(1)) SWIG_fail;
7906 {
7907 PyThreadState* __tstate = wxPyBeginAllowThreads();
7908 result = (long)(arg1)->TellI();
7909
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 {
7914 resultobj = SWIG_From_long((long)(result));
7915 }
7916 return resultobj;
7917 fail:
7918 return NULL;
7919 }
7920
7921
7922 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7923 PyObject *obj;
7924 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7925 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7926 Py_INCREF(obj);
7927 return Py_BuildValue((char *)"");
7928 }
7929 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7930 PyObject *resultobj;
7931 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7932 PyObject *arg2 = (PyObject *) 0 ;
7933 PyObject * obj0 = 0 ;
7934 PyObject * obj1 = 0 ;
7935 char *kwnames[] = {
7936 (char *) "self",(char *) "obj", NULL
7937 };
7938
7939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7941 if (SWIG_arg_fail(1)) SWIG_fail;
7942 arg2 = obj1;
7943 {
7944 PyThreadState* __tstate = wxPyBeginAllowThreads();
7945 wxOutputStream_write(arg1,arg2);
7946
7947 wxPyEndAllowThreads(__tstate);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 Py_INCREF(Py_None); resultobj = Py_None;
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7958 PyObject *obj;
7959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7960 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7961 Py_INCREF(obj);
7962 return Py_BuildValue((char *)"");
7963 }
7964 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7965 PyObject *resultobj;
7966 wxInputStream *arg1 = (wxInputStream *) 0 ;
7967 wxString *arg2 = 0 ;
7968 wxString *arg3 = 0 ;
7969 wxString *arg4 = 0 ;
7970 wxDateTime arg5 ;
7971 wxFSFile *result;
7972 wxPyInputStream *temp1 ;
7973 bool temp2 = false ;
7974 bool temp3 = false ;
7975 bool temp4 = false ;
7976 PyObject * obj0 = 0 ;
7977 PyObject * obj1 = 0 ;
7978 PyObject * obj2 = 0 ;
7979 PyObject * obj3 = 0 ;
7980 PyObject * obj4 = 0 ;
7981 char *kwnames[] = {
7982 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7983 };
7984
7985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7986 {
7987 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7988 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7989 } else {
7990 PyErr_Clear(); // clear the failure of the wxPyConvert above
7991 arg1 = wxPyCBInputStream_create(obj0, true);
7992 if (arg1 == NULL) {
7993 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7994 SWIG_fail;
7995 }
7996 }
7997 }
7998 {
7999 arg2 = wxString_in_helper(obj1);
8000 if (arg2 == NULL) SWIG_fail;
8001 temp2 = true;
8002 }
8003 {
8004 arg3 = wxString_in_helper(obj2);
8005 if (arg3 == NULL) SWIG_fail;
8006 temp3 = true;
8007 }
8008 {
8009 arg4 = wxString_in_helper(obj3);
8010 if (arg4 == NULL) SWIG_fail;
8011 temp4 = true;
8012 }
8013 {
8014 wxDateTime * argp;
8015 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8016 if (SWIG_arg_fail(5)) SWIG_fail;
8017 if (argp == NULL) {
8018 SWIG_null_ref("wxDateTime");
8019 }
8020 if (SWIG_arg_fail(5)) SWIG_fail;
8021 arg5 = *argp;
8022 }
8023 {
8024 PyThreadState* __tstate = wxPyBeginAllowThreads();
8025 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8026
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 {
8031 resultobj = wxPyMake_wxObject(result, 1);
8032 }
8033 {
8034 if (temp2)
8035 delete arg2;
8036 }
8037 {
8038 if (temp3)
8039 delete arg3;
8040 }
8041 {
8042 if (temp4)
8043 delete arg4;
8044 }
8045 return resultobj;
8046 fail:
8047 {
8048 if (temp2)
8049 delete arg2;
8050 }
8051 {
8052 if (temp3)
8053 delete arg3;
8054 }
8055 {
8056 if (temp4)
8057 delete arg4;
8058 }
8059 return NULL;
8060 }
8061
8062
8063 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8064 PyObject *resultobj;
8065 wxFSFile *arg1 = (wxFSFile *) 0 ;
8066 PyObject * obj0 = 0 ;
8067 char *kwnames[] = {
8068 (char *) "self", NULL
8069 };
8070
8071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8073 if (SWIG_arg_fail(1)) SWIG_fail;
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 delete arg1;
8077
8078 wxPyEndAllowThreads(__tstate);
8079 if (PyErr_Occurred()) SWIG_fail;
8080 }
8081 Py_INCREF(Py_None); resultobj = Py_None;
8082 return resultobj;
8083 fail:
8084 return NULL;
8085 }
8086
8087
8088 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8089 PyObject *resultobj;
8090 wxFSFile *arg1 = (wxFSFile *) 0 ;
8091 wxInputStream *result;
8092 PyObject * obj0 = 0 ;
8093 char *kwnames[] = {
8094 (char *) "self", NULL
8095 };
8096
8097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8099 if (SWIG_arg_fail(1)) SWIG_fail;
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (wxInputStream *)(arg1)->GetStream();
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 wxPyInputStream * _ptr = NULL;
8109
8110 if (result) {
8111 _ptr = new wxPyInputStream(result);
8112 }
8113 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8114 }
8115 return resultobj;
8116 fail:
8117 return NULL;
8118 }
8119
8120
8121 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8122 PyObject *resultobj;
8123 wxFSFile *arg1 = (wxFSFile *) 0 ;
8124 wxString *result;
8125 PyObject * obj0 = 0 ;
8126 char *kwnames[] = {
8127 (char *) "self", NULL
8128 };
8129
8130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8132 if (SWIG_arg_fail(1)) SWIG_fail;
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 {
8136 wxString const &_result_ref = (arg1)->GetMimeType();
8137 result = (wxString *) &_result_ref;
8138 }
8139
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 {
8144 #if wxUSE_UNICODE
8145 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8146 #else
8147 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8148 #endif
8149 }
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxFSFile *arg1 = (wxFSFile *) 0 ;
8159 wxString *result;
8160 PyObject * obj0 = 0 ;
8161 char *kwnames[] = {
8162 (char *) "self", NULL
8163 };
8164
8165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8167 if (SWIG_arg_fail(1)) SWIG_fail;
8168 {
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 {
8171 wxString const &_result_ref = (arg1)->GetLocation();
8172 result = (wxString *) &_result_ref;
8173 }
8174
8175 wxPyEndAllowThreads(__tstate);
8176 if (PyErr_Occurred()) SWIG_fail;
8177 }
8178 {
8179 #if wxUSE_UNICODE
8180 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8181 #else
8182 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8183 #endif
8184 }
8185 return resultobj;
8186 fail:
8187 return NULL;
8188 }
8189
8190
8191 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8192 PyObject *resultobj;
8193 wxFSFile *arg1 = (wxFSFile *) 0 ;
8194 wxString *result;
8195 PyObject * obj0 = 0 ;
8196 char *kwnames[] = {
8197 (char *) "self", NULL
8198 };
8199
8200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8202 if (SWIG_arg_fail(1)) SWIG_fail;
8203 {
8204 PyThreadState* __tstate = wxPyBeginAllowThreads();
8205 {
8206 wxString const &_result_ref = (arg1)->GetAnchor();
8207 result = (wxString *) &_result_ref;
8208 }
8209
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 {
8214 #if wxUSE_UNICODE
8215 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8216 #else
8217 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8218 #endif
8219 }
8220 return resultobj;
8221 fail:
8222 return NULL;
8223 }
8224
8225
8226 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8227 PyObject *resultobj;
8228 wxFSFile *arg1 = (wxFSFile *) 0 ;
8229 wxDateTime result;
8230 PyObject * obj0 = 0 ;
8231 char *kwnames[] = {
8232 (char *) "self", NULL
8233 };
8234
8235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8237 if (SWIG_arg_fail(1)) SWIG_fail;
8238 {
8239 PyThreadState* __tstate = wxPyBeginAllowThreads();
8240 result = (arg1)->GetModificationTime();
8241
8242 wxPyEndAllowThreads(__tstate);
8243 if (PyErr_Occurred()) SWIG_fail;
8244 }
8245 {
8246 wxDateTime * resultptr;
8247 resultptr = new wxDateTime((wxDateTime &)(result));
8248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8249 }
8250 return resultobj;
8251 fail:
8252 return NULL;
8253 }
8254
8255
8256 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8257 PyObject *obj;
8258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8259 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8260 Py_INCREF(obj);
8261 return Py_BuildValue((char *)"");
8262 }
8263 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8264 PyObject *obj;
8265 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8266 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8267 Py_INCREF(obj);
8268 return Py_BuildValue((char *)"");
8269 }
8270 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8271 PyObject *resultobj;
8272 wxPyFileSystemHandler *result;
8273 char *kwnames[] = {
8274 NULL
8275 };
8276
8277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8278 {
8279 PyThreadState* __tstate = wxPyBeginAllowThreads();
8280 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8281
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8286 return resultobj;
8287 fail:
8288 return NULL;
8289 }
8290
8291
8292 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8293 PyObject *resultobj;
8294 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8295 PyObject *arg2 = (PyObject *) 0 ;
8296 PyObject *arg3 = (PyObject *) 0 ;
8297 PyObject * obj0 = 0 ;
8298 PyObject * obj1 = 0 ;
8299 PyObject * obj2 = 0 ;
8300 char *kwnames[] = {
8301 (char *) "self",(char *) "self",(char *) "_class", NULL
8302 };
8303
8304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8306 if (SWIG_arg_fail(1)) SWIG_fail;
8307 arg2 = obj1;
8308 arg3 = obj2;
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 (arg1)->_setCallbackInfo(arg2,arg3);
8312
8313 wxPyEndAllowThreads(__tstate);
8314 if (PyErr_Occurred()) SWIG_fail;
8315 }
8316 Py_INCREF(Py_None); resultobj = Py_None;
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj;
8325 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8326 wxString *arg2 = 0 ;
8327 bool result;
8328 bool temp2 = false ;
8329 PyObject * obj0 = 0 ;
8330 PyObject * obj1 = 0 ;
8331 char *kwnames[] = {
8332 (char *) "self",(char *) "location", NULL
8333 };
8334
8335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8337 if (SWIG_arg_fail(1)) SWIG_fail;
8338 {
8339 arg2 = wxString_in_helper(obj1);
8340 if (arg2 == NULL) SWIG_fail;
8341 temp2 = true;
8342 }
8343 {
8344 PyThreadState* __tstate = wxPyBeginAllowThreads();
8345 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8346
8347 wxPyEndAllowThreads(__tstate);
8348 if (PyErr_Occurred()) SWIG_fail;
8349 }
8350 {
8351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8352 }
8353 {
8354 if (temp2)
8355 delete arg2;
8356 }
8357 return resultobj;
8358 fail:
8359 {
8360 if (temp2)
8361 delete arg2;
8362 }
8363 return NULL;
8364 }
8365
8366
8367 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8368 PyObject *resultobj;
8369 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8370 wxFileSystem *arg2 = 0 ;
8371 wxString *arg3 = 0 ;
8372 wxFSFile *result;
8373 bool temp3 = false ;
8374 PyObject * obj0 = 0 ;
8375 PyObject * obj1 = 0 ;
8376 PyObject * obj2 = 0 ;
8377 char *kwnames[] = {
8378 (char *) "self",(char *) "fs",(char *) "location", NULL
8379 };
8380
8381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8383 if (SWIG_arg_fail(1)) SWIG_fail;
8384 {
8385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8386 if (SWIG_arg_fail(2)) SWIG_fail;
8387 if (arg2 == NULL) {
8388 SWIG_null_ref("wxFileSystem");
8389 }
8390 if (SWIG_arg_fail(2)) SWIG_fail;
8391 }
8392 {
8393 arg3 = wxString_in_helper(obj2);
8394 if (arg3 == NULL) SWIG_fail;
8395 temp3 = true;
8396 }
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8400
8401 wxPyEndAllowThreads(__tstate);
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 {
8405 resultobj = wxPyMake_wxObject(result, 1);
8406 }
8407 {
8408 if (temp3)
8409 delete arg3;
8410 }
8411 return resultobj;
8412 fail:
8413 {
8414 if (temp3)
8415 delete arg3;
8416 }
8417 return NULL;
8418 }
8419
8420
8421 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj;
8423 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8424 wxString *arg2 = 0 ;
8425 int arg3 = (int) 0 ;
8426 wxString result;
8427 bool temp2 = false ;
8428 PyObject * obj0 = 0 ;
8429 PyObject * obj1 = 0 ;
8430 PyObject * obj2 = 0 ;
8431 char *kwnames[] = {
8432 (char *) "self",(char *) "spec",(char *) "flags", NULL
8433 };
8434
8435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8437 if (SWIG_arg_fail(1)) SWIG_fail;
8438 {
8439 arg2 = wxString_in_helper(obj1);
8440 if (arg2 == NULL) SWIG_fail;
8441 temp2 = true;
8442 }
8443 if (obj2) {
8444 {
8445 arg3 = (int)(SWIG_As_int(obj2));
8446 if (SWIG_arg_fail(3)) SWIG_fail;
8447 }
8448 }
8449 {
8450 PyThreadState* __tstate = wxPyBeginAllowThreads();
8451 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8452
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 {
8457 #if wxUSE_UNICODE
8458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8459 #else
8460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8461 #endif
8462 }
8463 {
8464 if (temp2)
8465 delete arg2;
8466 }
8467 return resultobj;
8468 fail:
8469 {
8470 if (temp2)
8471 delete arg2;
8472 }
8473 return NULL;
8474 }
8475
8476
8477 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8478 PyObject *resultobj;
8479 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8480 wxString result;
8481 PyObject * obj0 = 0 ;
8482 char *kwnames[] = {
8483 (char *) "self", NULL
8484 };
8485
8486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8488 if (SWIG_arg_fail(1)) SWIG_fail;
8489 {
8490 PyThreadState* __tstate = wxPyBeginAllowThreads();
8491 result = (arg1)->FindNext();
8492
8493 wxPyEndAllowThreads(__tstate);
8494 if (PyErr_Occurred()) SWIG_fail;
8495 }
8496 {
8497 #if wxUSE_UNICODE
8498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8499 #else
8500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8501 #endif
8502 }
8503 return resultobj;
8504 fail:
8505 return NULL;
8506 }
8507
8508
8509 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj;
8511 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8512 wxString *arg2 = 0 ;
8513 wxString result;
8514 bool temp2 = false ;
8515 PyObject * obj0 = 0 ;
8516 PyObject * obj1 = 0 ;
8517 char *kwnames[] = {
8518 (char *) "self",(char *) "location", NULL
8519 };
8520
8521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8523 if (SWIG_arg_fail(1)) SWIG_fail;
8524 {
8525 arg2 = wxString_in_helper(obj1);
8526 if (arg2 == NULL) SWIG_fail;
8527 temp2 = true;
8528 }
8529 {
8530 PyThreadState* __tstate = wxPyBeginAllowThreads();
8531 result = (arg1)->GetProtocol((wxString const &)*arg2);
8532
8533 wxPyEndAllowThreads(__tstate);
8534 if (PyErr_Occurred()) SWIG_fail;
8535 }
8536 {
8537 #if wxUSE_UNICODE
8538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8539 #else
8540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8541 #endif
8542 }
8543 {
8544 if (temp2)
8545 delete arg2;
8546 }
8547 return resultobj;
8548 fail:
8549 {
8550 if (temp2)
8551 delete arg2;
8552 }
8553 return NULL;
8554 }
8555
8556
8557 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8558 PyObject *resultobj;
8559 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8560 wxString *arg2 = 0 ;
8561 wxString result;
8562 bool temp2 = false ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char *kwnames[] = {
8566 (char *) "self",(char *) "location", NULL
8567 };
8568
8569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8571 if (SWIG_arg_fail(1)) SWIG_fail;
8572 {
8573 arg2 = wxString_in_helper(obj1);
8574 if (arg2 == NULL) SWIG_fail;
8575 temp2 = true;
8576 }
8577 {
8578 PyThreadState* __tstate = wxPyBeginAllowThreads();
8579 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8580
8581 wxPyEndAllowThreads(__tstate);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 {
8585 #if wxUSE_UNICODE
8586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8587 #else
8588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8589 #endif
8590 }
8591 {
8592 if (temp2)
8593 delete arg2;
8594 }
8595 return resultobj;
8596 fail:
8597 {
8598 if (temp2)
8599 delete arg2;
8600 }
8601 return NULL;
8602 }
8603
8604
8605 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8606 PyObject *resultobj;
8607 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8608 wxString *arg2 = 0 ;
8609 wxString result;
8610 bool temp2 = false ;
8611 PyObject * obj0 = 0 ;
8612 PyObject * obj1 = 0 ;
8613 char *kwnames[] = {
8614 (char *) "self",(char *) "location", NULL
8615 };
8616
8617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8619 if (SWIG_arg_fail(1)) SWIG_fail;
8620 {
8621 arg2 = wxString_in_helper(obj1);
8622 if (arg2 == NULL) SWIG_fail;
8623 temp2 = true;
8624 }
8625 {
8626 PyThreadState* __tstate = wxPyBeginAllowThreads();
8627 result = (arg1)->GetAnchor((wxString const &)*arg2);
8628
8629 wxPyEndAllowThreads(__tstate);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 {
8633 #if wxUSE_UNICODE
8634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8635 #else
8636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8637 #endif
8638 }
8639 {
8640 if (temp2)
8641 delete arg2;
8642 }
8643 return resultobj;
8644 fail:
8645 {
8646 if (temp2)
8647 delete arg2;
8648 }
8649 return NULL;
8650 }
8651
8652
8653 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj;
8655 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8656 wxString *arg2 = 0 ;
8657 wxString result;
8658 bool temp2 = false ;
8659 PyObject * obj0 = 0 ;
8660 PyObject * obj1 = 0 ;
8661 char *kwnames[] = {
8662 (char *) "self",(char *) "location", NULL
8663 };
8664
8665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8667 if (SWIG_arg_fail(1)) SWIG_fail;
8668 {
8669 arg2 = wxString_in_helper(obj1);
8670 if (arg2 == NULL) SWIG_fail;
8671 temp2 = true;
8672 }
8673 {
8674 PyThreadState* __tstate = wxPyBeginAllowThreads();
8675 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8676
8677 wxPyEndAllowThreads(__tstate);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 {
8681 #if wxUSE_UNICODE
8682 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8683 #else
8684 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8685 #endif
8686 }
8687 {
8688 if (temp2)
8689 delete arg2;
8690 }
8691 return resultobj;
8692 fail:
8693 {
8694 if (temp2)
8695 delete arg2;
8696 }
8697 return NULL;
8698 }
8699
8700
8701 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8702 PyObject *resultobj;
8703 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8704 wxString *arg2 = 0 ;
8705 wxString result;
8706 bool temp2 = false ;
8707 PyObject * obj0 = 0 ;
8708 PyObject * obj1 = 0 ;
8709 char *kwnames[] = {
8710 (char *) "self",(char *) "location", NULL
8711 };
8712
8713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8715 if (SWIG_arg_fail(1)) SWIG_fail;
8716 {
8717 arg2 = wxString_in_helper(obj1);
8718 if (arg2 == NULL) SWIG_fail;
8719 temp2 = true;
8720 }
8721 {
8722 PyThreadState* __tstate = wxPyBeginAllowThreads();
8723 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8724
8725 wxPyEndAllowThreads(__tstate);
8726 if (PyErr_Occurred()) SWIG_fail;
8727 }
8728 {
8729 #if wxUSE_UNICODE
8730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8731 #else
8732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8733 #endif
8734 }
8735 {
8736 if (temp2)
8737 delete arg2;
8738 }
8739 return resultobj;
8740 fail:
8741 {
8742 if (temp2)
8743 delete arg2;
8744 }
8745 return NULL;
8746 }
8747
8748
8749 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8750 PyObject *obj;
8751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8752 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8753 Py_INCREF(obj);
8754 return Py_BuildValue((char *)"");
8755 }
8756 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8757 PyObject *resultobj;
8758 wxFileSystem *result;
8759 char *kwnames[] = {
8760 NULL
8761 };
8762
8763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8764 {
8765 PyThreadState* __tstate = wxPyBeginAllowThreads();
8766 result = (wxFileSystem *)new wxFileSystem();
8767
8768 wxPyEndAllowThreads(__tstate);
8769 if (PyErr_Occurred()) SWIG_fail;
8770 }
8771 {
8772 resultobj = wxPyMake_wxObject(result, 1);
8773 }
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj;
8782 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8783 PyObject * obj0 = 0 ;
8784 char *kwnames[] = {
8785 (char *) "self", NULL
8786 };
8787
8788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8790 if (SWIG_arg_fail(1)) SWIG_fail;
8791 {
8792 PyThreadState* __tstate = wxPyBeginAllowThreads();
8793 delete arg1;
8794
8795 wxPyEndAllowThreads(__tstate);
8796 if (PyErr_Occurred()) SWIG_fail;
8797 }
8798 Py_INCREF(Py_None); resultobj = Py_None;
8799 return resultobj;
8800 fail:
8801 return NULL;
8802 }
8803
8804
8805 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8806 PyObject *resultobj;
8807 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8808 wxString *arg2 = 0 ;
8809 bool arg3 = (bool) false ;
8810 bool temp2 = false ;
8811 PyObject * obj0 = 0 ;
8812 PyObject * obj1 = 0 ;
8813 PyObject * obj2 = 0 ;
8814 char *kwnames[] = {
8815 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8816 };
8817
8818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8820 if (SWIG_arg_fail(1)) SWIG_fail;
8821 {
8822 arg2 = wxString_in_helper(obj1);
8823 if (arg2 == NULL) SWIG_fail;
8824 temp2 = true;
8825 }
8826 if (obj2) {
8827 {
8828 arg3 = (bool)(SWIG_As_bool(obj2));
8829 if (SWIG_arg_fail(3)) SWIG_fail;
8830 }
8831 }
8832 {
8833 PyThreadState* __tstate = wxPyBeginAllowThreads();
8834 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8835
8836 wxPyEndAllowThreads(__tstate);
8837 if (PyErr_Occurred()) SWIG_fail;
8838 }
8839 Py_INCREF(Py_None); resultobj = Py_None;
8840 {
8841 if (temp2)
8842 delete arg2;
8843 }
8844 return resultobj;
8845 fail:
8846 {
8847 if (temp2)
8848 delete arg2;
8849 }
8850 return NULL;
8851 }
8852
8853
8854 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8855 PyObject *resultobj;
8856 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8857 wxString result;
8858 PyObject * obj0 = 0 ;
8859 char *kwnames[] = {
8860 (char *) "self", NULL
8861 };
8862
8863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8865 if (SWIG_arg_fail(1)) SWIG_fail;
8866 {
8867 PyThreadState* __tstate = wxPyBeginAllowThreads();
8868 result = (arg1)->GetPath();
8869
8870 wxPyEndAllowThreads(__tstate);
8871 if (PyErr_Occurred()) SWIG_fail;
8872 }
8873 {
8874 #if wxUSE_UNICODE
8875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8876 #else
8877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8878 #endif
8879 }
8880 return resultobj;
8881 fail:
8882 return NULL;
8883 }
8884
8885
8886 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8887 PyObject *resultobj;
8888 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8889 wxString *arg2 = 0 ;
8890 wxFSFile *result;
8891 bool temp2 = false ;
8892 PyObject * obj0 = 0 ;
8893 PyObject * obj1 = 0 ;
8894 char *kwnames[] = {
8895 (char *) "self",(char *) "location", NULL
8896 };
8897
8898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8900 if (SWIG_arg_fail(1)) SWIG_fail;
8901 {
8902 arg2 = wxString_in_helper(obj1);
8903 if (arg2 == NULL) SWIG_fail;
8904 temp2 = true;
8905 }
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8909
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 {
8914 resultobj = wxPyMake_wxObject(result, 1);
8915 }
8916 {
8917 if (temp2)
8918 delete arg2;
8919 }
8920 return resultobj;
8921 fail:
8922 {
8923 if (temp2)
8924 delete arg2;
8925 }
8926 return NULL;
8927 }
8928
8929
8930 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj;
8932 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8933 wxString *arg2 = 0 ;
8934 int arg3 = (int) 0 ;
8935 wxString result;
8936 bool temp2 = false ;
8937 PyObject * obj0 = 0 ;
8938 PyObject * obj1 = 0 ;
8939 PyObject * obj2 = 0 ;
8940 char *kwnames[] = {
8941 (char *) "self",(char *) "spec",(char *) "flags", NULL
8942 };
8943
8944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8946 if (SWIG_arg_fail(1)) SWIG_fail;
8947 {
8948 arg2 = wxString_in_helper(obj1);
8949 if (arg2 == NULL) SWIG_fail;
8950 temp2 = true;
8951 }
8952 if (obj2) {
8953 {
8954 arg3 = (int)(SWIG_As_int(obj2));
8955 if (SWIG_arg_fail(3)) SWIG_fail;
8956 }
8957 }
8958 {
8959 PyThreadState* __tstate = wxPyBeginAllowThreads();
8960 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8961
8962 wxPyEndAllowThreads(__tstate);
8963 if (PyErr_Occurred()) SWIG_fail;
8964 }
8965 {
8966 #if wxUSE_UNICODE
8967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8968 #else
8969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8970 #endif
8971 }
8972 {
8973 if (temp2)
8974 delete arg2;
8975 }
8976 return resultobj;
8977 fail:
8978 {
8979 if (temp2)
8980 delete arg2;
8981 }
8982 return NULL;
8983 }
8984
8985
8986 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8987 PyObject *resultobj;
8988 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8989 wxString result;
8990 PyObject * obj0 = 0 ;
8991 char *kwnames[] = {
8992 (char *) "self", NULL
8993 };
8994
8995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8997 if (SWIG_arg_fail(1)) SWIG_fail;
8998 {
8999 PyThreadState* __tstate = wxPyBeginAllowThreads();
9000 result = (arg1)->FindNext();
9001
9002 wxPyEndAllowThreads(__tstate);
9003 if (PyErr_Occurred()) SWIG_fail;
9004 }
9005 {
9006 #if wxUSE_UNICODE
9007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9008 #else
9009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9010 #endif
9011 }
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj;
9020 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9021 PyObject * obj0 = 0 ;
9022 char *kwnames[] = {
9023 (char *) "handler", NULL
9024 };
9025
9026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9028 if (SWIG_arg_fail(1)) SWIG_fail;
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 wxFileSystem::AddHandler(arg1);
9032
9033 wxPyEndAllowThreads(__tstate);
9034 if (PyErr_Occurred()) SWIG_fail;
9035 }
9036 Py_INCREF(Py_None); resultobj = Py_None;
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj;
9045 char *kwnames[] = {
9046 NULL
9047 };
9048
9049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9050 {
9051 PyThreadState* __tstate = wxPyBeginAllowThreads();
9052 wxFileSystem::CleanUpHandlers();
9053
9054 wxPyEndAllowThreads(__tstate);
9055 if (PyErr_Occurred()) SWIG_fail;
9056 }
9057 Py_INCREF(Py_None); resultobj = Py_None;
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9065 PyObject *resultobj;
9066 wxString *arg1 = 0 ;
9067 wxString result;
9068 bool temp1 = false ;
9069 PyObject * obj0 = 0 ;
9070 char *kwnames[] = {
9071 (char *) "filename", NULL
9072 };
9073
9074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9075 {
9076 arg1 = wxString_in_helper(obj0);
9077 if (arg1 == NULL) SWIG_fail;
9078 temp1 = true;
9079 }
9080 {
9081 PyThreadState* __tstate = wxPyBeginAllowThreads();
9082 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9083
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 {
9088 #if wxUSE_UNICODE
9089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9090 #else
9091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9092 #endif
9093 }
9094 {
9095 if (temp1)
9096 delete arg1;
9097 }
9098 return resultobj;
9099 fail:
9100 {
9101 if (temp1)
9102 delete arg1;
9103 }
9104 return NULL;
9105 }
9106
9107
9108 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9109 PyObject *resultobj;
9110 wxString *arg1 = 0 ;
9111 wxString result;
9112 bool temp1 = false ;
9113 PyObject * obj0 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "url", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9119 {
9120 arg1 = wxString_in_helper(obj0);
9121 if (arg1 == NULL) SWIG_fail;
9122 temp1 = true;
9123 }
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 result = FileSystem_URLToFileName((wxString const &)*arg1);
9127
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 {
9132 #if wxUSE_UNICODE
9133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9134 #else
9135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9136 #endif
9137 }
9138 {
9139 if (temp1)
9140 delete arg1;
9141 }
9142 return resultobj;
9143 fail:
9144 {
9145 if (temp1)
9146 delete arg1;
9147 }
9148 return NULL;
9149 }
9150
9151
9152 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9153 PyObject *obj;
9154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9155 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9156 Py_INCREF(obj);
9157 return Py_BuildValue((char *)"");
9158 }
9159 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj;
9161 wxInternetFSHandler *result;
9162 char *kwnames[] = {
9163 NULL
9164 };
9165
9166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9167 {
9168 PyThreadState* __tstate = wxPyBeginAllowThreads();
9169 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9170
9171 wxPyEndAllowThreads(__tstate);
9172 if (PyErr_Occurred()) SWIG_fail;
9173 }
9174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9175 return resultobj;
9176 fail:
9177 return NULL;
9178 }
9179
9180
9181 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj;
9183 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9184 wxString *arg2 = 0 ;
9185 bool result;
9186 bool temp2 = false ;
9187 PyObject * obj0 = 0 ;
9188 PyObject * obj1 = 0 ;
9189 char *kwnames[] = {
9190 (char *) "self",(char *) "location", NULL
9191 };
9192
9193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9195 if (SWIG_arg_fail(1)) SWIG_fail;
9196 {
9197 arg2 = wxString_in_helper(obj1);
9198 if (arg2 == NULL) SWIG_fail;
9199 temp2 = true;
9200 }
9201 {
9202 PyThreadState* __tstate = wxPyBeginAllowThreads();
9203 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9204
9205 wxPyEndAllowThreads(__tstate);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 {
9209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9210 }
9211 {
9212 if (temp2)
9213 delete arg2;
9214 }
9215 return resultobj;
9216 fail:
9217 {
9218 if (temp2)
9219 delete arg2;
9220 }
9221 return NULL;
9222 }
9223
9224
9225 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9226 PyObject *resultobj;
9227 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9228 wxFileSystem *arg2 = 0 ;
9229 wxString *arg3 = 0 ;
9230 wxFSFile *result;
9231 bool temp3 = false ;
9232 PyObject * obj0 = 0 ;
9233 PyObject * obj1 = 0 ;
9234 PyObject * obj2 = 0 ;
9235 char *kwnames[] = {
9236 (char *) "self",(char *) "fs",(char *) "location", NULL
9237 };
9238
9239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9241 if (SWIG_arg_fail(1)) SWIG_fail;
9242 {
9243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9244 if (SWIG_arg_fail(2)) SWIG_fail;
9245 if (arg2 == NULL) {
9246 SWIG_null_ref("wxFileSystem");
9247 }
9248 if (SWIG_arg_fail(2)) SWIG_fail;
9249 }
9250 {
9251 arg3 = wxString_in_helper(obj2);
9252 if (arg3 == NULL) SWIG_fail;
9253 temp3 = true;
9254 }
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9258
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 {
9263 resultobj = wxPyMake_wxObject(result, 1);
9264 }
9265 {
9266 if (temp3)
9267 delete arg3;
9268 }
9269 return resultobj;
9270 fail:
9271 {
9272 if (temp3)
9273 delete arg3;
9274 }
9275 return NULL;
9276 }
9277
9278
9279 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9280 PyObject *obj;
9281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9282 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9283 Py_INCREF(obj);
9284 return Py_BuildValue((char *)"");
9285 }
9286 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9287 PyObject *resultobj;
9288 wxZipFSHandler *result;
9289 char *kwnames[] = {
9290 NULL
9291 };
9292
9293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9294 {
9295 PyThreadState* __tstate = wxPyBeginAllowThreads();
9296 result = (wxZipFSHandler *)new wxZipFSHandler();
9297
9298 wxPyEndAllowThreads(__tstate);
9299 if (PyErr_Occurred()) SWIG_fail;
9300 }
9301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9302 return resultobj;
9303 fail:
9304 return NULL;
9305 }
9306
9307
9308 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9309 PyObject *resultobj;
9310 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9311 wxString *arg2 = 0 ;
9312 bool result;
9313 bool temp2 = false ;
9314 PyObject * obj0 = 0 ;
9315 PyObject * obj1 = 0 ;
9316 char *kwnames[] = {
9317 (char *) "self",(char *) "location", NULL
9318 };
9319
9320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9322 if (SWIG_arg_fail(1)) SWIG_fail;
9323 {
9324 arg2 = wxString_in_helper(obj1);
9325 if (arg2 == NULL) SWIG_fail;
9326 temp2 = true;
9327 }
9328 {
9329 PyThreadState* __tstate = wxPyBeginAllowThreads();
9330 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9331
9332 wxPyEndAllowThreads(__tstate);
9333 if (PyErr_Occurred()) SWIG_fail;
9334 }
9335 {
9336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9337 }
9338 {
9339 if (temp2)
9340 delete arg2;
9341 }
9342 return resultobj;
9343 fail:
9344 {
9345 if (temp2)
9346 delete arg2;
9347 }
9348 return NULL;
9349 }
9350
9351
9352 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9353 PyObject *resultobj;
9354 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9355 wxFileSystem *arg2 = 0 ;
9356 wxString *arg3 = 0 ;
9357 wxFSFile *result;
9358 bool temp3 = false ;
9359 PyObject * obj0 = 0 ;
9360 PyObject * obj1 = 0 ;
9361 PyObject * obj2 = 0 ;
9362 char *kwnames[] = {
9363 (char *) "self",(char *) "fs",(char *) "location", NULL
9364 };
9365
9366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9368 if (SWIG_arg_fail(1)) SWIG_fail;
9369 {
9370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9371 if (SWIG_arg_fail(2)) SWIG_fail;
9372 if (arg2 == NULL) {
9373 SWIG_null_ref("wxFileSystem");
9374 }
9375 if (SWIG_arg_fail(2)) SWIG_fail;
9376 }
9377 {
9378 arg3 = wxString_in_helper(obj2);
9379 if (arg3 == NULL) SWIG_fail;
9380 temp3 = true;
9381 }
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9385
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 {
9390 resultobj = wxPyMake_wxObject(result, 1);
9391 }
9392 {
9393 if (temp3)
9394 delete arg3;
9395 }
9396 return resultobj;
9397 fail:
9398 {
9399 if (temp3)
9400 delete arg3;
9401 }
9402 return NULL;
9403 }
9404
9405
9406 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj;
9408 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9409 wxString *arg2 = 0 ;
9410 int arg3 = (int) 0 ;
9411 wxString result;
9412 bool temp2 = false ;
9413 PyObject * obj0 = 0 ;
9414 PyObject * obj1 = 0 ;
9415 PyObject * obj2 = 0 ;
9416 char *kwnames[] = {
9417 (char *) "self",(char *) "spec",(char *) "flags", NULL
9418 };
9419
9420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9422 if (SWIG_arg_fail(1)) SWIG_fail;
9423 {
9424 arg2 = wxString_in_helper(obj1);
9425 if (arg2 == NULL) SWIG_fail;
9426 temp2 = true;
9427 }
9428 if (obj2) {
9429 {
9430 arg3 = (int)(SWIG_As_int(obj2));
9431 if (SWIG_arg_fail(3)) SWIG_fail;
9432 }
9433 }
9434 {
9435 PyThreadState* __tstate = wxPyBeginAllowThreads();
9436 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9437
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 {
9442 #if wxUSE_UNICODE
9443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9444 #else
9445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9446 #endif
9447 }
9448 {
9449 if (temp2)
9450 delete arg2;
9451 }
9452 return resultobj;
9453 fail:
9454 {
9455 if (temp2)
9456 delete arg2;
9457 }
9458 return NULL;
9459 }
9460
9461
9462 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9463 PyObject *resultobj;
9464 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9465 wxString result;
9466 PyObject * obj0 = 0 ;
9467 char *kwnames[] = {
9468 (char *) "self", NULL
9469 };
9470
9471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9473 if (SWIG_arg_fail(1)) SWIG_fail;
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (arg1)->FindNext();
9477
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 {
9482 #if wxUSE_UNICODE
9483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9484 #else
9485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9486 #endif
9487 }
9488 return resultobj;
9489 fail:
9490 return NULL;
9491 }
9492
9493
9494 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9495 PyObject *obj;
9496 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9497 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9498 Py_INCREF(obj);
9499 return Py_BuildValue((char *)"");
9500 }
9501 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9502 PyObject *resultobj;
9503 wxString *arg1 = 0 ;
9504 wxImage *arg2 = 0 ;
9505 long arg3 ;
9506 bool temp1 = false ;
9507 PyObject * obj0 = 0 ;
9508 PyObject * obj1 = 0 ;
9509 PyObject * obj2 = 0 ;
9510 char *kwnames[] = {
9511 (char *) "filename",(char *) "image",(char *) "type", NULL
9512 };
9513
9514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9515 {
9516 arg1 = wxString_in_helper(obj0);
9517 if (arg1 == NULL) SWIG_fail;
9518 temp1 = true;
9519 }
9520 {
9521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9522 if (SWIG_arg_fail(2)) SWIG_fail;
9523 if (arg2 == NULL) {
9524 SWIG_null_ref("wxImage");
9525 }
9526 if (SWIG_arg_fail(2)) SWIG_fail;
9527 }
9528 {
9529 arg3 = (long)(SWIG_As_long(obj2));
9530 if (SWIG_arg_fail(3)) SWIG_fail;
9531 }
9532 {
9533 PyThreadState* __tstate = wxPyBeginAllowThreads();
9534 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9535
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 Py_INCREF(Py_None); resultobj = Py_None;
9540 {
9541 if (temp1)
9542 delete arg1;
9543 }
9544 return resultobj;
9545 fail:
9546 {
9547 if (temp1)
9548 delete arg1;
9549 }
9550 return NULL;
9551 }
9552
9553
9554 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9555 PyObject *resultobj;
9556 wxString *arg1 = 0 ;
9557 wxBitmap *arg2 = 0 ;
9558 long arg3 ;
9559 bool temp1 = false ;
9560 PyObject * obj0 = 0 ;
9561 PyObject * obj1 = 0 ;
9562 PyObject * obj2 = 0 ;
9563 char *kwnames[] = {
9564 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9565 };
9566
9567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9568 {
9569 arg1 = wxString_in_helper(obj0);
9570 if (arg1 == NULL) SWIG_fail;
9571 temp1 = true;
9572 }
9573 {
9574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9575 if (SWIG_arg_fail(2)) SWIG_fail;
9576 if (arg2 == NULL) {
9577 SWIG_null_ref("wxBitmap");
9578 }
9579 if (SWIG_arg_fail(2)) SWIG_fail;
9580 }
9581 {
9582 arg3 = (long)(SWIG_As_long(obj2));
9583 if (SWIG_arg_fail(3)) SWIG_fail;
9584 }
9585 {
9586 PyThreadState* __tstate = wxPyBeginAllowThreads();
9587 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9588
9589 wxPyEndAllowThreads(__tstate);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 Py_INCREF(Py_None); resultobj = Py_None;
9593 {
9594 if (temp1)
9595 delete arg1;
9596 }
9597 return resultobj;
9598 fail:
9599 {
9600 if (temp1)
9601 delete arg1;
9602 }
9603 return NULL;
9604 }
9605
9606
9607 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9608 PyObject *resultobj;
9609 wxString *arg1 = 0 ;
9610 PyObject *arg2 = (PyObject *) 0 ;
9611 bool temp1 = false ;
9612 PyObject * obj0 = 0 ;
9613 PyObject * obj1 = 0 ;
9614 char *kwnames[] = {
9615 (char *) "filename",(char *) "data", NULL
9616 };
9617
9618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9619 {
9620 arg1 = wxString_in_helper(obj0);
9621 if (arg1 == NULL) SWIG_fail;
9622 temp1 = true;
9623 }
9624 arg2 = obj1;
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9628
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 Py_INCREF(Py_None); resultobj = Py_None;
9633 {
9634 if (temp1)
9635 delete arg1;
9636 }
9637 return resultobj;
9638 fail:
9639 {
9640 if (temp1)
9641 delete arg1;
9642 }
9643 return NULL;
9644 }
9645
9646
9647 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9648 PyObject *resultobj;
9649 wxMemoryFSHandler *result;
9650 char *kwnames[] = {
9651 NULL
9652 };
9653
9654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9658
9659 wxPyEndAllowThreads(__tstate);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9663 return resultobj;
9664 fail:
9665 return NULL;
9666 }
9667
9668
9669 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9670 PyObject *resultobj;
9671 wxString *arg1 = 0 ;
9672 bool temp1 = false ;
9673 PyObject * obj0 = 0 ;
9674 char *kwnames[] = {
9675 (char *) "filename", NULL
9676 };
9677
9678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9679 {
9680 arg1 = wxString_in_helper(obj0);
9681 if (arg1 == NULL) SWIG_fail;
9682 temp1 = true;
9683 }
9684 {
9685 PyThreadState* __tstate = wxPyBeginAllowThreads();
9686 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9687
9688 wxPyEndAllowThreads(__tstate);
9689 if (PyErr_Occurred()) SWIG_fail;
9690 }
9691 Py_INCREF(Py_None); resultobj = Py_None;
9692 {
9693 if (temp1)
9694 delete arg1;
9695 }
9696 return resultobj;
9697 fail:
9698 {
9699 if (temp1)
9700 delete arg1;
9701 }
9702 return NULL;
9703 }
9704
9705
9706 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9707 PyObject *resultobj;
9708 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9709 wxString *arg2 = 0 ;
9710 bool result;
9711 bool temp2 = false ;
9712 PyObject * obj0 = 0 ;
9713 PyObject * obj1 = 0 ;
9714 char *kwnames[] = {
9715 (char *) "self",(char *) "location", NULL
9716 };
9717
9718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9720 if (SWIG_arg_fail(1)) SWIG_fail;
9721 {
9722 arg2 = wxString_in_helper(obj1);
9723 if (arg2 == NULL) SWIG_fail;
9724 temp2 = true;
9725 }
9726 {
9727 PyThreadState* __tstate = wxPyBeginAllowThreads();
9728 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9729
9730 wxPyEndAllowThreads(__tstate);
9731 if (PyErr_Occurred()) SWIG_fail;
9732 }
9733 {
9734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9735 }
9736 {
9737 if (temp2)
9738 delete arg2;
9739 }
9740 return resultobj;
9741 fail:
9742 {
9743 if (temp2)
9744 delete arg2;
9745 }
9746 return NULL;
9747 }
9748
9749
9750 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9751 PyObject *resultobj;
9752 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9753 wxFileSystem *arg2 = 0 ;
9754 wxString *arg3 = 0 ;
9755 wxFSFile *result;
9756 bool temp3 = false ;
9757 PyObject * obj0 = 0 ;
9758 PyObject * obj1 = 0 ;
9759 PyObject * obj2 = 0 ;
9760 char *kwnames[] = {
9761 (char *) "self",(char *) "fs",(char *) "location", NULL
9762 };
9763
9764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9766 if (SWIG_arg_fail(1)) SWIG_fail;
9767 {
9768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9769 if (SWIG_arg_fail(2)) SWIG_fail;
9770 if (arg2 == NULL) {
9771 SWIG_null_ref("wxFileSystem");
9772 }
9773 if (SWIG_arg_fail(2)) SWIG_fail;
9774 }
9775 {
9776 arg3 = wxString_in_helper(obj2);
9777 if (arg3 == NULL) SWIG_fail;
9778 temp3 = true;
9779 }
9780 {
9781 PyThreadState* __tstate = wxPyBeginAllowThreads();
9782 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9783
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 {
9788 resultobj = wxPyMake_wxObject(result, 1);
9789 }
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 return resultobj;
9795 fail:
9796 {
9797 if (temp3)
9798 delete arg3;
9799 }
9800 return NULL;
9801 }
9802
9803
9804 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9805 PyObject *resultobj;
9806 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9807 wxString *arg2 = 0 ;
9808 int arg3 = (int) 0 ;
9809 wxString result;
9810 bool temp2 = false ;
9811 PyObject * obj0 = 0 ;
9812 PyObject * obj1 = 0 ;
9813 PyObject * obj2 = 0 ;
9814 char *kwnames[] = {
9815 (char *) "self",(char *) "spec",(char *) "flags", NULL
9816 };
9817
9818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9820 if (SWIG_arg_fail(1)) SWIG_fail;
9821 {
9822 arg2 = wxString_in_helper(obj1);
9823 if (arg2 == NULL) SWIG_fail;
9824 temp2 = true;
9825 }
9826 if (obj2) {
9827 {
9828 arg3 = (int)(SWIG_As_int(obj2));
9829 if (SWIG_arg_fail(3)) SWIG_fail;
9830 }
9831 }
9832 {
9833 PyThreadState* __tstate = wxPyBeginAllowThreads();
9834 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9835
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 {
9840 #if wxUSE_UNICODE
9841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9842 #else
9843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9844 #endif
9845 }
9846 {
9847 if (temp2)
9848 delete arg2;
9849 }
9850 return resultobj;
9851 fail:
9852 {
9853 if (temp2)
9854 delete arg2;
9855 }
9856 return NULL;
9857 }
9858
9859
9860 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9861 PyObject *resultobj;
9862 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9863 wxString result;
9864 PyObject * obj0 = 0 ;
9865 char *kwnames[] = {
9866 (char *) "self", NULL
9867 };
9868
9869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9871 if (SWIG_arg_fail(1)) SWIG_fail;
9872 {
9873 PyThreadState* __tstate = wxPyBeginAllowThreads();
9874 result = (arg1)->FindNext();
9875
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 {
9880 #if wxUSE_UNICODE
9881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9882 #else
9883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9884 #endif
9885 }
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9893 PyObject *obj;
9894 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9895 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9896 Py_INCREF(obj);
9897 return Py_BuildValue((char *)"");
9898 }
9899 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj;
9901 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9902 wxString result;
9903 PyObject * obj0 = 0 ;
9904 char *kwnames[] = {
9905 (char *) "self", NULL
9906 };
9907
9908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9910 if (SWIG_arg_fail(1)) SWIG_fail;
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 result = (arg1)->GetName();
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 {
9919 #if wxUSE_UNICODE
9920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9921 #else
9922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9923 #endif
9924 }
9925 return resultobj;
9926 fail:
9927 return NULL;
9928 }
9929
9930
9931 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9932 PyObject *resultobj;
9933 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9934 wxString result;
9935 PyObject * obj0 = 0 ;
9936 char *kwnames[] = {
9937 (char *) "self", NULL
9938 };
9939
9940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9942 if (SWIG_arg_fail(1)) SWIG_fail;
9943 {
9944 PyThreadState* __tstate = wxPyBeginAllowThreads();
9945 result = (arg1)->GetExtension();
9946
9947 wxPyEndAllowThreads(__tstate);
9948 if (PyErr_Occurred()) SWIG_fail;
9949 }
9950 {
9951 #if wxUSE_UNICODE
9952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9953 #else
9954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9955 #endif
9956 }
9957 return resultobj;
9958 fail:
9959 return NULL;
9960 }
9961
9962
9963 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9964 PyObject *resultobj;
9965 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9966 long result;
9967 PyObject * obj0 = 0 ;
9968 char *kwnames[] = {
9969 (char *) "self", NULL
9970 };
9971
9972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9974 if (SWIG_arg_fail(1)) SWIG_fail;
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 result = (long)(arg1)->GetType();
9978
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 {
9983 resultobj = SWIG_From_long((long)(result));
9984 }
9985 return resultobj;
9986 fail:
9987 return NULL;
9988 }
9989
9990
9991 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9992 PyObject *resultobj;
9993 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9994 wxString result;
9995 PyObject * obj0 = 0 ;
9996 char *kwnames[] = {
9997 (char *) "self", NULL
9998 };
9999
10000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10002 if (SWIG_arg_fail(1)) SWIG_fail;
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = (arg1)->GetMimeType();
10006
10007 wxPyEndAllowThreads(__tstate);
10008 if (PyErr_Occurred()) SWIG_fail;
10009 }
10010 {
10011 #if wxUSE_UNICODE
10012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10013 #else
10014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10015 #endif
10016 }
10017 return resultobj;
10018 fail:
10019 return NULL;
10020 }
10021
10022
10023 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10024 PyObject *resultobj;
10025 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10026 wxString *arg2 = 0 ;
10027 bool result;
10028 bool temp2 = false ;
10029 PyObject * obj0 = 0 ;
10030 PyObject * obj1 = 0 ;
10031 char *kwnames[] = {
10032 (char *) "self",(char *) "name", NULL
10033 };
10034
10035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10037 if (SWIG_arg_fail(1)) SWIG_fail;
10038 {
10039 arg2 = wxString_in_helper(obj1);
10040 if (arg2 == NULL) SWIG_fail;
10041 temp2 = true;
10042 }
10043 {
10044 PyThreadState* __tstate = wxPyBeginAllowThreads();
10045 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10046
10047 wxPyEndAllowThreads(__tstate);
10048 if (PyErr_Occurred()) SWIG_fail;
10049 }
10050 {
10051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10052 }
10053 {
10054 if (temp2)
10055 delete arg2;
10056 }
10057 return resultobj;
10058 fail:
10059 {
10060 if (temp2)
10061 delete arg2;
10062 }
10063 return NULL;
10064 }
10065
10066
10067 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10068 PyObject *resultobj;
10069 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10070 wxString *arg2 = 0 ;
10071 bool temp2 = false ;
10072 PyObject * obj0 = 0 ;
10073 PyObject * obj1 = 0 ;
10074 char *kwnames[] = {
10075 (char *) "self",(char *) "name", NULL
10076 };
10077
10078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10080 if (SWIG_arg_fail(1)) SWIG_fail;
10081 {
10082 arg2 = wxString_in_helper(obj1);
10083 if (arg2 == NULL) SWIG_fail;
10084 temp2 = true;
10085 }
10086 {
10087 PyThreadState* __tstate = wxPyBeginAllowThreads();
10088 (arg1)->SetName((wxString const &)*arg2);
10089
10090 wxPyEndAllowThreads(__tstate);
10091 if (PyErr_Occurred()) SWIG_fail;
10092 }
10093 Py_INCREF(Py_None); resultobj = Py_None;
10094 {
10095 if (temp2)
10096 delete arg2;
10097 }
10098 return resultobj;
10099 fail:
10100 {
10101 if (temp2)
10102 delete arg2;
10103 }
10104 return NULL;
10105 }
10106
10107
10108 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10109 PyObject *resultobj;
10110 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10111 wxString *arg2 = 0 ;
10112 bool temp2 = false ;
10113 PyObject * obj0 = 0 ;
10114 PyObject * obj1 = 0 ;
10115 char *kwnames[] = {
10116 (char *) "self",(char *) "extension", NULL
10117 };
10118
10119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10121 if (SWIG_arg_fail(1)) SWIG_fail;
10122 {
10123 arg2 = wxString_in_helper(obj1);
10124 if (arg2 == NULL) SWIG_fail;
10125 temp2 = true;
10126 }
10127 {
10128 PyThreadState* __tstate = wxPyBeginAllowThreads();
10129 (arg1)->SetExtension((wxString const &)*arg2);
10130
10131 wxPyEndAllowThreads(__tstate);
10132 if (PyErr_Occurred()) SWIG_fail;
10133 }
10134 Py_INCREF(Py_None); resultobj = Py_None;
10135 {
10136 if (temp2)
10137 delete arg2;
10138 }
10139 return resultobj;
10140 fail:
10141 {
10142 if (temp2)
10143 delete arg2;
10144 }
10145 return NULL;
10146 }
10147
10148
10149 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10150 PyObject *resultobj;
10151 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10152 long arg2 ;
10153 PyObject * obj0 = 0 ;
10154 PyObject * obj1 = 0 ;
10155 char *kwnames[] = {
10156 (char *) "self",(char *) "type", NULL
10157 };
10158
10159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10161 if (SWIG_arg_fail(1)) SWIG_fail;
10162 {
10163 arg2 = (long)(SWIG_As_long(obj1));
10164 if (SWIG_arg_fail(2)) SWIG_fail;
10165 }
10166 {
10167 PyThreadState* __tstate = wxPyBeginAllowThreads();
10168 (arg1)->SetType(arg2);
10169
10170 wxPyEndAllowThreads(__tstate);
10171 if (PyErr_Occurred()) SWIG_fail;
10172 }
10173 Py_INCREF(Py_None); resultobj = Py_None;
10174 return resultobj;
10175 fail:
10176 return NULL;
10177 }
10178
10179
10180 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10181 PyObject *resultobj;
10182 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10183 wxString *arg2 = 0 ;
10184 bool temp2 = false ;
10185 PyObject * obj0 = 0 ;
10186 PyObject * obj1 = 0 ;
10187 char *kwnames[] = {
10188 (char *) "self",(char *) "mimetype", NULL
10189 };
10190
10191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10193 if (SWIG_arg_fail(1)) SWIG_fail;
10194 {
10195 arg2 = wxString_in_helper(obj1);
10196 if (arg2 == NULL) SWIG_fail;
10197 temp2 = true;
10198 }
10199 {
10200 PyThreadState* __tstate = wxPyBeginAllowThreads();
10201 (arg1)->SetMimeType((wxString const &)*arg2);
10202
10203 wxPyEndAllowThreads(__tstate);
10204 if (PyErr_Occurred()) SWIG_fail;
10205 }
10206 Py_INCREF(Py_None); resultobj = Py_None;
10207 {
10208 if (temp2)
10209 delete arg2;
10210 }
10211 return resultobj;
10212 fail:
10213 {
10214 if (temp2)
10215 delete arg2;
10216 }
10217 return NULL;
10218 }
10219
10220
10221 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10222 PyObject *obj;
10223 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10224 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10225 Py_INCREF(obj);
10226 return Py_BuildValue((char *)"");
10227 }
10228 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10229 PyObject *resultobj;
10230 wxImageHistogram *result;
10231 char *kwnames[] = {
10232 NULL
10233 };
10234
10235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10236 {
10237 PyThreadState* __tstate = wxPyBeginAllowThreads();
10238 result = (wxImageHistogram *)new wxImageHistogram();
10239
10240 wxPyEndAllowThreads(__tstate);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj;
10252 byte arg1 ;
10253 byte arg2 ;
10254 byte arg3 ;
10255 unsigned long result;
10256 PyObject * obj0 = 0 ;
10257 PyObject * obj1 = 0 ;
10258 PyObject * obj2 = 0 ;
10259 char *kwnames[] = {
10260 (char *) "r",(char *) "g",(char *) "b", NULL
10261 };
10262
10263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10264 {
10265 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10266 if (SWIG_arg_fail(1)) SWIG_fail;
10267 }
10268 {
10269 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10270 if (SWIG_arg_fail(2)) SWIG_fail;
10271 }
10272 {
10273 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10274 if (SWIG_arg_fail(3)) SWIG_fail;
10275 }
10276 {
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10279
10280 wxPyEndAllowThreads(__tstate);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 {
10284 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10285 }
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10293 PyObject *resultobj;
10294 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10295 byte *arg2 = (byte *) 0 ;
10296 byte *arg3 = (byte *) 0 ;
10297 byte *arg4 = (byte *) 0 ;
10298 byte arg5 = (byte) 1 ;
10299 byte arg6 = (byte) 0 ;
10300 byte arg7 = (byte) 0 ;
10301 bool result;
10302 byte temp2 ;
10303 int res2 = 0 ;
10304 byte temp3 ;
10305 int res3 = 0 ;
10306 byte temp4 ;
10307 int res4 = 0 ;
10308 PyObject * obj0 = 0 ;
10309 PyObject * obj1 = 0 ;
10310 PyObject * obj2 = 0 ;
10311 PyObject * obj3 = 0 ;
10312 char *kwnames[] = {
10313 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10314 };
10315
10316 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10317 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10318 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10321 if (SWIG_arg_fail(1)) SWIG_fail;
10322 if (obj1) {
10323 {
10324 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10325 if (SWIG_arg_fail(5)) SWIG_fail;
10326 }
10327 }
10328 if (obj2) {
10329 {
10330 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10331 if (SWIG_arg_fail(6)) SWIG_fail;
10332 }
10333 }
10334 if (obj3) {
10335 {
10336 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10337 if (SWIG_arg_fail(7)) SWIG_fail;
10338 }
10339 }
10340 {
10341 PyThreadState* __tstate = wxPyBeginAllowThreads();
10342 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10343
10344 wxPyEndAllowThreads(__tstate);
10345 if (PyErr_Occurred()) SWIG_fail;
10346 }
10347 {
10348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10349 }
10350 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10351 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10352 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10353 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10354 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10355 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10356 return resultobj;
10357 fail:
10358 return NULL;
10359 }
10360
10361
10362 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10363 PyObject *resultobj;
10364 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10365 unsigned long arg2 ;
10366 unsigned long result;
10367 PyObject * obj0 = 0 ;
10368 PyObject * obj1 = 0 ;
10369 char *kwnames[] = {
10370 (char *) "self",(char *) "key", NULL
10371 };
10372
10373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10375 if (SWIG_arg_fail(1)) SWIG_fail;
10376 {
10377 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10378 if (SWIG_arg_fail(2)) SWIG_fail;
10379 }
10380 {
10381 PyThreadState* __tstate = wxPyBeginAllowThreads();
10382 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10383
10384 wxPyEndAllowThreads(__tstate);
10385 if (PyErr_Occurred()) SWIG_fail;
10386 }
10387 {
10388 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10389 }
10390 return resultobj;
10391 fail:
10392 return NULL;
10393 }
10394
10395
10396 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10397 PyObject *resultobj;
10398 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10399 byte arg2 ;
10400 byte arg3 ;
10401 byte arg4 ;
10402 unsigned long result;
10403 PyObject * obj0 = 0 ;
10404 PyObject * obj1 = 0 ;
10405 PyObject * obj2 = 0 ;
10406 PyObject * obj3 = 0 ;
10407 char *kwnames[] = {
10408 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10409 };
10410
10411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10413 if (SWIG_arg_fail(1)) SWIG_fail;
10414 {
10415 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10416 if (SWIG_arg_fail(2)) SWIG_fail;
10417 }
10418 {
10419 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10420 if (SWIG_arg_fail(3)) SWIG_fail;
10421 }
10422 {
10423 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10424 if (SWIG_arg_fail(4)) SWIG_fail;
10425 }
10426 {
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10429
10430 wxPyEndAllowThreads(__tstate);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 {
10434 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10435 }
10436 return resultobj;
10437 fail:
10438 return NULL;
10439 }
10440
10441
10442 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10443 PyObject *resultobj;
10444 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10445 wxColour *arg2 = 0 ;
10446 unsigned long result;
10447 wxColour temp2 ;
10448 PyObject * obj0 = 0 ;
10449 PyObject * obj1 = 0 ;
10450 char *kwnames[] = {
10451 (char *) "self",(char *) "colour", NULL
10452 };
10453
10454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10456 if (SWIG_arg_fail(1)) SWIG_fail;
10457 {
10458 arg2 = &temp2;
10459 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10460 }
10461 {
10462 PyThreadState* __tstate = wxPyBeginAllowThreads();
10463 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10464
10465 wxPyEndAllowThreads(__tstate);
10466 if (PyErr_Occurred()) SWIG_fail;
10467 }
10468 {
10469 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10470 }
10471 return resultobj;
10472 fail:
10473 return NULL;
10474 }
10475
10476
10477 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10478 PyObject *obj;
10479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10480 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10481 Py_INCREF(obj);
10482 return Py_BuildValue((char *)"");
10483 }
10484 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10485 PyObject *resultobj;
10486 wxString *arg1 = 0 ;
10487 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10488 int arg3 = (int) -1 ;
10489 wxImage *result;
10490 bool temp1 = false ;
10491 PyObject * obj0 = 0 ;
10492 PyObject * obj1 = 0 ;
10493 PyObject * obj2 = 0 ;
10494 char *kwnames[] = {
10495 (char *) "name",(char *) "type",(char *) "index", NULL
10496 };
10497
10498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10499 {
10500 arg1 = wxString_in_helper(obj0);
10501 if (arg1 == NULL) SWIG_fail;
10502 temp1 = true;
10503 }
10504 if (obj1) {
10505 {
10506 arg2 = (long)(SWIG_As_long(obj1));
10507 if (SWIG_arg_fail(2)) SWIG_fail;
10508 }
10509 }
10510 if (obj2) {
10511 {
10512 arg3 = (int)(SWIG_As_int(obj2));
10513 if (SWIG_arg_fail(3)) SWIG_fail;
10514 }
10515 }
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10519
10520 wxPyEndAllowThreads(__tstate);
10521 if (PyErr_Occurred()) SWIG_fail;
10522 }
10523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10524 {
10525 if (temp1)
10526 delete arg1;
10527 }
10528 return resultobj;
10529 fail:
10530 {
10531 if (temp1)
10532 delete arg1;
10533 }
10534 return NULL;
10535 }
10536
10537
10538 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10539 PyObject *resultobj;
10540 wxImage *arg1 = (wxImage *) 0 ;
10541 PyObject * obj0 = 0 ;
10542 char *kwnames[] = {
10543 (char *) "self", NULL
10544 };
10545
10546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10548 if (SWIG_arg_fail(1)) SWIG_fail;
10549 {
10550 PyThreadState* __tstate = wxPyBeginAllowThreads();
10551 delete arg1;
10552
10553 wxPyEndAllowThreads(__tstate);
10554 if (PyErr_Occurred()) SWIG_fail;
10555 }
10556 Py_INCREF(Py_None); resultobj = Py_None;
10557 return resultobj;
10558 fail:
10559 return NULL;
10560 }
10561
10562
10563 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10564 PyObject *resultobj;
10565 wxString *arg1 = 0 ;
10566 wxString *arg2 = 0 ;
10567 int arg3 = (int) -1 ;
10568 wxImage *result;
10569 bool temp1 = false ;
10570 bool temp2 = false ;
10571 PyObject * obj0 = 0 ;
10572 PyObject * obj1 = 0 ;
10573 PyObject * obj2 = 0 ;
10574 char *kwnames[] = {
10575 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10576 };
10577
10578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10579 {
10580 arg1 = wxString_in_helper(obj0);
10581 if (arg1 == NULL) SWIG_fail;
10582 temp1 = true;
10583 }
10584 {
10585 arg2 = wxString_in_helper(obj1);
10586 if (arg2 == NULL) SWIG_fail;
10587 temp2 = true;
10588 }
10589 if (obj2) {
10590 {
10591 arg3 = (int)(SWIG_As_int(obj2));
10592 if (SWIG_arg_fail(3)) SWIG_fail;
10593 }
10594 }
10595 {
10596 PyThreadState* __tstate = wxPyBeginAllowThreads();
10597 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10598
10599 wxPyEndAllowThreads(__tstate);
10600 if (PyErr_Occurred()) SWIG_fail;
10601 }
10602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10603 {
10604 if (temp1)
10605 delete arg1;
10606 }
10607 {
10608 if (temp2)
10609 delete arg2;
10610 }
10611 return resultobj;
10612 fail:
10613 {
10614 if (temp1)
10615 delete arg1;
10616 }
10617 {
10618 if (temp2)
10619 delete arg2;
10620 }
10621 return NULL;
10622 }
10623
10624
10625 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10626 PyObject *resultobj;
10627 wxInputStream *arg1 = 0 ;
10628 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10629 int arg3 = (int) -1 ;
10630 wxImage *result;
10631 wxPyInputStream *temp1 ;
10632 bool created1 ;
10633 PyObject * obj0 = 0 ;
10634 PyObject * obj1 = 0 ;
10635 PyObject * obj2 = 0 ;
10636 char *kwnames[] = {
10637 (char *) "stream",(char *) "type",(char *) "index", NULL
10638 };
10639
10640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10641 {
10642 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10643 arg1 = temp1->m_wxis;
10644 created1 = false;
10645 } else {
10646 PyErr_Clear(); // clear the failure of the wxPyConvert above
10647 arg1 = wxPyCBInputStream_create(obj0, false);
10648 if (arg1 == NULL) {
10649 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10650 SWIG_fail;
10651 }
10652 created1 = true;
10653 }
10654 }
10655 if (obj1) {
10656 {
10657 arg2 = (long)(SWIG_As_long(obj1));
10658 if (SWIG_arg_fail(2)) SWIG_fail;
10659 }
10660 }
10661 if (obj2) {
10662 {
10663 arg3 = (int)(SWIG_As_int(obj2));
10664 if (SWIG_arg_fail(3)) SWIG_fail;
10665 }
10666 }
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10670
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10675 {
10676 if (created1) delete arg1;
10677 }
10678 return resultobj;
10679 fail:
10680 {
10681 if (created1) delete arg1;
10682 }
10683 return NULL;
10684 }
10685
10686
10687 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10688 PyObject *resultobj;
10689 wxInputStream *arg1 = 0 ;
10690 wxString *arg2 = 0 ;
10691 int arg3 = (int) -1 ;
10692 wxImage *result;
10693 wxPyInputStream *temp1 ;
10694 bool created1 ;
10695 bool temp2 = false ;
10696 PyObject * obj0 = 0 ;
10697 PyObject * obj1 = 0 ;
10698 PyObject * obj2 = 0 ;
10699 char *kwnames[] = {
10700 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10701 };
10702
10703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10704 {
10705 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10706 arg1 = temp1->m_wxis;
10707 created1 = false;
10708 } else {
10709 PyErr_Clear(); // clear the failure of the wxPyConvert above
10710 arg1 = wxPyCBInputStream_create(obj0, false);
10711 if (arg1 == NULL) {
10712 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10713 SWIG_fail;
10714 }
10715 created1 = true;
10716 }
10717 }
10718 {
10719 arg2 = wxString_in_helper(obj1);
10720 if (arg2 == NULL) SWIG_fail;
10721 temp2 = true;
10722 }
10723 if (obj2) {
10724 {
10725 arg3 = (int)(SWIG_As_int(obj2));
10726 if (SWIG_arg_fail(3)) SWIG_fail;
10727 }
10728 }
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10732
10733 wxPyEndAllowThreads(__tstate);
10734 if (PyErr_Occurred()) SWIG_fail;
10735 }
10736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10737 {
10738 if (created1) delete arg1;
10739 }
10740 {
10741 if (temp2)
10742 delete arg2;
10743 }
10744 return resultobj;
10745 fail:
10746 {
10747 if (created1) delete arg1;
10748 }
10749 {
10750 if (temp2)
10751 delete arg2;
10752 }
10753 return NULL;
10754 }
10755
10756
10757 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10758 PyObject *resultobj;
10759 int arg1 = (int) 0 ;
10760 int arg2 = (int) 0 ;
10761 bool arg3 = (bool) true ;
10762 wxImage *result;
10763 PyObject * obj0 = 0 ;
10764 PyObject * obj1 = 0 ;
10765 PyObject * obj2 = 0 ;
10766 char *kwnames[] = {
10767 (char *) "width",(char *) "height",(char *) "clear", NULL
10768 };
10769
10770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10771 if (obj0) {
10772 {
10773 arg1 = (int)(SWIG_As_int(obj0));
10774 if (SWIG_arg_fail(1)) SWIG_fail;
10775 }
10776 }
10777 if (obj1) {
10778 {
10779 arg2 = (int)(SWIG_As_int(obj1));
10780 if (SWIG_arg_fail(2)) SWIG_fail;
10781 }
10782 }
10783 if (obj2) {
10784 {
10785 arg3 = (bool)(SWIG_As_bool(obj2));
10786 if (SWIG_arg_fail(3)) SWIG_fail;
10787 }
10788 }
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10792
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10797 return resultobj;
10798 fail:
10799 return NULL;
10800 }
10801
10802
10803 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10804 PyObject *resultobj;
10805 wxBitmap *arg1 = 0 ;
10806 wxImage *result;
10807 PyObject * obj0 = 0 ;
10808 char *kwnames[] = {
10809 (char *) "bitmap", NULL
10810 };
10811
10812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10813 {
10814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10815 if (SWIG_arg_fail(1)) SWIG_fail;
10816 if (arg1 == NULL) {
10817 SWIG_null_ref("wxBitmap");
10818 }
10819 if (SWIG_arg_fail(1)) SWIG_fail;
10820 }
10821 {
10822 if (!wxPyCheckForApp()) SWIG_fail;
10823 PyThreadState* __tstate = wxPyBeginAllowThreads();
10824 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10825
10826 wxPyEndAllowThreads(__tstate);
10827 if (PyErr_Occurred()) SWIG_fail;
10828 }
10829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 int arg1 ;
10839 int arg2 ;
10840 buffer arg3 ;
10841 int arg4 ;
10842 wxImage *result;
10843 PyObject * obj0 = 0 ;
10844 PyObject * obj1 = 0 ;
10845 PyObject * obj2 = 0 ;
10846 char *kwnames[] = {
10847 (char *) "width",(char *) "height",(char *) "data", NULL
10848 };
10849
10850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10851 {
10852 arg1 = (int)(SWIG_As_int(obj0));
10853 if (SWIG_arg_fail(1)) SWIG_fail;
10854 }
10855 {
10856 arg2 = (int)(SWIG_As_int(obj1));
10857 if (SWIG_arg_fail(2)) SWIG_fail;
10858 }
10859 {
10860 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10861 }
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10865
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj;
10878 int arg1 ;
10879 int arg2 ;
10880 buffer arg3 ;
10881 int arg4 ;
10882 buffer arg5 ;
10883 int arg6 ;
10884 wxImage *result;
10885 PyObject * obj0 = 0 ;
10886 PyObject * obj1 = 0 ;
10887 PyObject * obj2 = 0 ;
10888 PyObject * obj3 = 0 ;
10889 char *kwnames[] = {
10890 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10891 };
10892
10893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10894 {
10895 arg1 = (int)(SWIG_As_int(obj0));
10896 if (SWIG_arg_fail(1)) SWIG_fail;
10897 }
10898 {
10899 arg2 = (int)(SWIG_As_int(obj1));
10900 if (SWIG_arg_fail(2)) SWIG_fail;
10901 }
10902 {
10903 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10904 }
10905 {
10906 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10907 }
10908 {
10909 PyThreadState* __tstate = wxPyBeginAllowThreads();
10910 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10911
10912 wxPyEndAllowThreads(__tstate);
10913 if (PyErr_Occurred()) SWIG_fail;
10914 }
10915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10916 return resultobj;
10917 fail:
10918 return NULL;
10919 }
10920
10921
10922 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10923 PyObject *resultobj;
10924 wxImage *arg1 = (wxImage *) 0 ;
10925 int arg2 ;
10926 int arg3 ;
10927 bool arg4 = (bool) true ;
10928 PyObject * obj0 = 0 ;
10929 PyObject * obj1 = 0 ;
10930 PyObject * obj2 = 0 ;
10931 PyObject * obj3 = 0 ;
10932 char *kwnames[] = {
10933 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
10934 };
10935
10936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10938 if (SWIG_arg_fail(1)) SWIG_fail;
10939 {
10940 arg2 = (int)(SWIG_As_int(obj1));
10941 if (SWIG_arg_fail(2)) SWIG_fail;
10942 }
10943 {
10944 arg3 = (int)(SWIG_As_int(obj2));
10945 if (SWIG_arg_fail(3)) SWIG_fail;
10946 }
10947 if (obj3) {
10948 {
10949 arg4 = (bool)(SWIG_As_bool(obj3));
10950 if (SWIG_arg_fail(4)) SWIG_fail;
10951 }
10952 }
10953 {
10954 PyThreadState* __tstate = wxPyBeginAllowThreads();
10955 (arg1)->Create(arg2,arg3,arg4);
10956
10957 wxPyEndAllowThreads(__tstate);
10958 if (PyErr_Occurred()) SWIG_fail;
10959 }
10960 Py_INCREF(Py_None); resultobj = Py_None;
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj;
10969 wxImage *arg1 = (wxImage *) 0 ;
10970 PyObject * obj0 = 0 ;
10971 char *kwnames[] = {
10972 (char *) "self", NULL
10973 };
10974
10975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10977 if (SWIG_arg_fail(1)) SWIG_fail;
10978 {
10979 PyThreadState* __tstate = wxPyBeginAllowThreads();
10980 (arg1)->Destroy();
10981
10982 wxPyEndAllowThreads(__tstate);
10983 if (PyErr_Occurred()) SWIG_fail;
10984 }
10985 Py_INCREF(Py_None); resultobj = Py_None;
10986 return resultobj;
10987 fail:
10988 return NULL;
10989 }
10990
10991
10992 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10993 PyObject *resultobj;
10994 wxImage *arg1 = (wxImage *) 0 ;
10995 int arg2 ;
10996 int arg3 ;
10997 SwigValueWrapper<wxImage > result;
10998 PyObject * obj0 = 0 ;
10999 PyObject * obj1 = 0 ;
11000 PyObject * obj2 = 0 ;
11001 char *kwnames[] = {
11002 (char *) "self",(char *) "width",(char *) "height", NULL
11003 };
11004
11005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11007 if (SWIG_arg_fail(1)) SWIG_fail;
11008 {
11009 arg2 = (int)(SWIG_As_int(obj1));
11010 if (SWIG_arg_fail(2)) SWIG_fail;
11011 }
11012 {
11013 arg3 = (int)(SWIG_As_int(obj2));
11014 if (SWIG_arg_fail(3)) SWIG_fail;
11015 }
11016 {
11017 PyThreadState* __tstate = wxPyBeginAllowThreads();
11018 result = (arg1)->Scale(arg2,arg3);
11019
11020 wxPyEndAllowThreads(__tstate);
11021 if (PyErr_Occurred()) SWIG_fail;
11022 }
11023 {
11024 wxImage * resultptr;
11025 resultptr = new wxImage((wxImage &)(result));
11026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11027 }
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11035 PyObject *resultobj;
11036 wxImage *arg1 = (wxImage *) 0 ;
11037 int arg2 ;
11038 int arg3 ;
11039 SwigValueWrapper<wxImage > result;
11040 PyObject * obj0 = 0 ;
11041 PyObject * obj1 = 0 ;
11042 PyObject * obj2 = 0 ;
11043 char *kwnames[] = {
11044 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11045 };
11046
11047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11049 if (SWIG_arg_fail(1)) SWIG_fail;
11050 {
11051 arg2 = (int)(SWIG_As_int(obj1));
11052 if (SWIG_arg_fail(2)) SWIG_fail;
11053 }
11054 {
11055 arg3 = (int)(SWIG_As_int(obj2));
11056 if (SWIG_arg_fail(3)) SWIG_fail;
11057 }
11058 {
11059 PyThreadState* __tstate = wxPyBeginAllowThreads();
11060 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11061
11062 wxPyEndAllowThreads(__tstate);
11063 if (PyErr_Occurred()) SWIG_fail;
11064 }
11065 {
11066 wxImage * resultptr;
11067 resultptr = new wxImage((wxImage &)(result));
11068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11069 }
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11077 PyObject *resultobj;
11078 wxImage *arg1 = (wxImage *) 0 ;
11079 int arg2 ;
11080 int arg3 ;
11081 wxImage *result;
11082 PyObject * obj0 = 0 ;
11083 PyObject * obj1 = 0 ;
11084 PyObject * obj2 = 0 ;
11085 char *kwnames[] = {
11086 (char *) "self",(char *) "width",(char *) "height", NULL
11087 };
11088
11089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11091 if (SWIG_arg_fail(1)) SWIG_fail;
11092 {
11093 arg2 = (int)(SWIG_As_int(obj1));
11094 if (SWIG_arg_fail(2)) SWIG_fail;
11095 }
11096 {
11097 arg3 = (int)(SWIG_As_int(obj2));
11098 if (SWIG_arg_fail(3)) SWIG_fail;
11099 }
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 {
11103 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11104 result = (wxImage *) &_result_ref;
11105 }
11106
11107 wxPyEndAllowThreads(__tstate);
11108 if (PyErr_Occurred()) SWIG_fail;
11109 }
11110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11118 PyObject *resultobj;
11119 wxImage *arg1 = (wxImage *) 0 ;
11120 wxSize *arg2 = 0 ;
11121 wxPoint *arg3 = 0 ;
11122 int arg4 = (int) -1 ;
11123 int arg5 = (int) -1 ;
11124 int arg6 = (int) -1 ;
11125 wxImage *result;
11126 wxSize temp2 ;
11127 wxPoint temp3 ;
11128 PyObject * obj0 = 0 ;
11129 PyObject * obj1 = 0 ;
11130 PyObject * obj2 = 0 ;
11131 PyObject * obj3 = 0 ;
11132 PyObject * obj4 = 0 ;
11133 PyObject * obj5 = 0 ;
11134 char *kwnames[] = {
11135 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11136 };
11137
11138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11140 if (SWIG_arg_fail(1)) SWIG_fail;
11141 {
11142 arg2 = &temp2;
11143 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11144 }
11145 {
11146 arg3 = &temp3;
11147 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11148 }
11149 if (obj3) {
11150 {
11151 arg4 = (int)(SWIG_As_int(obj3));
11152 if (SWIG_arg_fail(4)) SWIG_fail;
11153 }
11154 }
11155 if (obj4) {
11156 {
11157 arg5 = (int)(SWIG_As_int(obj4));
11158 if (SWIG_arg_fail(5)) SWIG_fail;
11159 }
11160 }
11161 if (obj5) {
11162 {
11163 arg6 = (int)(SWIG_As_int(obj5));
11164 if (SWIG_arg_fail(6)) SWIG_fail;
11165 }
11166 }
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 {
11170 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11171 result = (wxImage *) &_result_ref;
11172 }
11173
11174 wxPyEndAllowThreads(__tstate);
11175 if (PyErr_Occurred()) SWIG_fail;
11176 }
11177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11178 return resultobj;
11179 fail:
11180 return NULL;
11181 }
11182
11183
11184 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11185 PyObject *resultobj;
11186 wxImage *arg1 = (wxImage *) 0 ;
11187 int arg2 ;
11188 int arg3 ;
11189 byte arg4 ;
11190 byte arg5 ;
11191 byte arg6 ;
11192 PyObject * obj0 = 0 ;
11193 PyObject * obj1 = 0 ;
11194 PyObject * obj2 = 0 ;
11195 PyObject * obj3 = 0 ;
11196 PyObject * obj4 = 0 ;
11197 PyObject * obj5 = 0 ;
11198 char *kwnames[] = {
11199 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11200 };
11201
11202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11204 if (SWIG_arg_fail(1)) SWIG_fail;
11205 {
11206 arg2 = (int)(SWIG_As_int(obj1));
11207 if (SWIG_arg_fail(2)) SWIG_fail;
11208 }
11209 {
11210 arg3 = (int)(SWIG_As_int(obj2));
11211 if (SWIG_arg_fail(3)) SWIG_fail;
11212 }
11213 {
11214 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11215 if (SWIG_arg_fail(4)) SWIG_fail;
11216 }
11217 {
11218 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11219 if (SWIG_arg_fail(5)) SWIG_fail;
11220 }
11221 {
11222 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11223 if (SWIG_arg_fail(6)) SWIG_fail;
11224 }
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11228
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 Py_INCREF(Py_None); resultobj = Py_None;
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11240 PyObject *resultobj;
11241 wxImage *arg1 = (wxImage *) 0 ;
11242 wxRect *arg2 = 0 ;
11243 byte arg3 ;
11244 byte arg4 ;
11245 byte arg5 ;
11246 wxRect temp2 ;
11247 PyObject * obj0 = 0 ;
11248 PyObject * obj1 = 0 ;
11249 PyObject * obj2 = 0 ;
11250 PyObject * obj3 = 0 ;
11251 PyObject * obj4 = 0 ;
11252 char *kwnames[] = {
11253 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11254 };
11255
11256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11258 if (SWIG_arg_fail(1)) SWIG_fail;
11259 {
11260 arg2 = &temp2;
11261 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11262 }
11263 {
11264 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11265 if (SWIG_arg_fail(3)) SWIG_fail;
11266 }
11267 {
11268 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11269 if (SWIG_arg_fail(4)) SWIG_fail;
11270 }
11271 {
11272 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11273 if (SWIG_arg_fail(5)) SWIG_fail;
11274 }
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11278
11279 wxPyEndAllowThreads(__tstate);
11280 if (PyErr_Occurred()) SWIG_fail;
11281 }
11282 Py_INCREF(Py_None); resultobj = Py_None;
11283 return resultobj;
11284 fail:
11285 return NULL;
11286 }
11287
11288
11289 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11290 PyObject *resultobj;
11291 wxImage *arg1 = (wxImage *) 0 ;
11292 int arg2 ;
11293 int arg3 ;
11294 byte result;
11295 PyObject * obj0 = 0 ;
11296 PyObject * obj1 = 0 ;
11297 PyObject * obj2 = 0 ;
11298 char *kwnames[] = {
11299 (char *) "self",(char *) "x",(char *) "y", NULL
11300 };
11301
11302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11304 if (SWIG_arg_fail(1)) SWIG_fail;
11305 {
11306 arg2 = (int)(SWIG_As_int(obj1));
11307 if (SWIG_arg_fail(2)) SWIG_fail;
11308 }
11309 {
11310 arg3 = (int)(SWIG_As_int(obj2));
11311 if (SWIG_arg_fail(3)) SWIG_fail;
11312 }
11313 {
11314 PyThreadState* __tstate = wxPyBeginAllowThreads();
11315 result = (byte)(arg1)->GetRed(arg2,arg3);
11316
11317 wxPyEndAllowThreads(__tstate);
11318 if (PyErr_Occurred()) SWIG_fail;
11319 }
11320 {
11321 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11322 }
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11330 PyObject *resultobj;
11331 wxImage *arg1 = (wxImage *) 0 ;
11332 int arg2 ;
11333 int arg3 ;
11334 byte result;
11335 PyObject * obj0 = 0 ;
11336 PyObject * obj1 = 0 ;
11337 PyObject * obj2 = 0 ;
11338 char *kwnames[] = {
11339 (char *) "self",(char *) "x",(char *) "y", NULL
11340 };
11341
11342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11344 if (SWIG_arg_fail(1)) SWIG_fail;
11345 {
11346 arg2 = (int)(SWIG_As_int(obj1));
11347 if (SWIG_arg_fail(2)) SWIG_fail;
11348 }
11349 {
11350 arg3 = (int)(SWIG_As_int(obj2));
11351 if (SWIG_arg_fail(3)) SWIG_fail;
11352 }
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 result = (byte)(arg1)->GetGreen(arg2,arg3);
11356
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 {
11361 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11362 }
11363 return resultobj;
11364 fail:
11365 return NULL;
11366 }
11367
11368
11369 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11370 PyObject *resultobj;
11371 wxImage *arg1 = (wxImage *) 0 ;
11372 int arg2 ;
11373 int arg3 ;
11374 byte result;
11375 PyObject * obj0 = 0 ;
11376 PyObject * obj1 = 0 ;
11377 PyObject * obj2 = 0 ;
11378 char *kwnames[] = {
11379 (char *) "self",(char *) "x",(char *) "y", NULL
11380 };
11381
11382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11384 if (SWIG_arg_fail(1)) SWIG_fail;
11385 {
11386 arg2 = (int)(SWIG_As_int(obj1));
11387 if (SWIG_arg_fail(2)) SWIG_fail;
11388 }
11389 {
11390 arg3 = (int)(SWIG_As_int(obj2));
11391 if (SWIG_arg_fail(3)) SWIG_fail;
11392 }
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (byte)(arg1)->GetBlue(arg2,arg3);
11396
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 {
11401 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj;
11411 wxImage *arg1 = (wxImage *) 0 ;
11412 int arg2 ;
11413 int arg3 ;
11414 byte arg4 ;
11415 PyObject * obj0 = 0 ;
11416 PyObject * obj1 = 0 ;
11417 PyObject * obj2 = 0 ;
11418 PyObject * obj3 = 0 ;
11419 char *kwnames[] = {
11420 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11421 };
11422
11423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11425 if (SWIG_arg_fail(1)) SWIG_fail;
11426 {
11427 arg2 = (int)(SWIG_As_int(obj1));
11428 if (SWIG_arg_fail(2)) SWIG_fail;
11429 }
11430 {
11431 arg3 = (int)(SWIG_As_int(obj2));
11432 if (SWIG_arg_fail(3)) SWIG_fail;
11433 }
11434 {
11435 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11436 if (SWIG_arg_fail(4)) SWIG_fail;
11437 }
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 (arg1)->SetAlpha(arg2,arg3,arg4);
11441
11442 wxPyEndAllowThreads(__tstate);
11443 if (PyErr_Occurred()) SWIG_fail;
11444 }
11445 Py_INCREF(Py_None); resultobj = Py_None;
11446 return resultobj;
11447 fail:
11448 return NULL;
11449 }
11450
11451
11452 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11453 PyObject *resultobj;
11454 wxImage *arg1 = (wxImage *) 0 ;
11455 int arg2 ;
11456 int arg3 ;
11457 byte result;
11458 PyObject * obj0 = 0 ;
11459 PyObject * obj1 = 0 ;
11460 PyObject * obj2 = 0 ;
11461 char *kwnames[] = {
11462 (char *) "self",(char *) "x",(char *) "y", NULL
11463 };
11464
11465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11467 if (SWIG_arg_fail(1)) SWIG_fail;
11468 {
11469 arg2 = (int)(SWIG_As_int(obj1));
11470 if (SWIG_arg_fail(2)) SWIG_fail;
11471 }
11472 {
11473 arg3 = (int)(SWIG_As_int(obj2));
11474 if (SWIG_arg_fail(3)) SWIG_fail;
11475 }
11476 {
11477 PyThreadState* __tstate = wxPyBeginAllowThreads();
11478 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11479
11480 wxPyEndAllowThreads(__tstate);
11481 if (PyErr_Occurred()) SWIG_fail;
11482 }
11483 {
11484 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11485 }
11486 return resultobj;
11487 fail:
11488 return NULL;
11489 }
11490
11491
11492 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11493 PyObject *resultobj;
11494 wxImage *arg1 = (wxImage *) 0 ;
11495 bool result;
11496 PyObject * obj0 = 0 ;
11497 char *kwnames[] = {
11498 (char *) "self", NULL
11499 };
11500
11501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11503 if (SWIG_arg_fail(1)) SWIG_fail;
11504 {
11505 PyThreadState* __tstate = wxPyBeginAllowThreads();
11506 result = (bool)(arg1)->HasAlpha();
11507
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 {
11512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11513 }
11514 return resultobj;
11515 fail:
11516 return NULL;
11517 }
11518
11519
11520 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11521 PyObject *resultobj;
11522 wxImage *arg1 = (wxImage *) 0 ;
11523 PyObject * obj0 = 0 ;
11524 char *kwnames[] = {
11525 (char *) "self", NULL
11526 };
11527
11528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11530 if (SWIG_arg_fail(1)) SWIG_fail;
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 (arg1)->InitAlpha();
11534
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 Py_INCREF(Py_None); resultobj = Py_None;
11539 return resultobj;
11540 fail:
11541 return NULL;
11542 }
11543
11544
11545 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj;
11547 wxImage *arg1 = (wxImage *) 0 ;
11548 int arg2 ;
11549 int arg3 ;
11550 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11551 bool result;
11552 PyObject * obj0 = 0 ;
11553 PyObject * obj1 = 0 ;
11554 PyObject * obj2 = 0 ;
11555 PyObject * obj3 = 0 ;
11556 char *kwnames[] = {
11557 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11558 };
11559
11560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11562 if (SWIG_arg_fail(1)) SWIG_fail;
11563 {
11564 arg2 = (int)(SWIG_As_int(obj1));
11565 if (SWIG_arg_fail(2)) SWIG_fail;
11566 }
11567 {
11568 arg3 = (int)(SWIG_As_int(obj2));
11569 if (SWIG_arg_fail(3)) SWIG_fail;
11570 }
11571 if (obj3) {
11572 {
11573 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11574 if (SWIG_arg_fail(4)) SWIG_fail;
11575 }
11576 }
11577 {
11578 PyThreadState* __tstate = wxPyBeginAllowThreads();
11579 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11580
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 {
11585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11586 }
11587 return resultobj;
11588 fail:
11589 return NULL;
11590 }
11591
11592
11593 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11594 PyObject *resultobj;
11595 wxImage *arg1 = (wxImage *) 0 ;
11596 byte *arg2 = (byte *) 0 ;
11597 byte *arg3 = (byte *) 0 ;
11598 byte *arg4 = (byte *) 0 ;
11599 byte arg5 = (byte) 0 ;
11600 byte arg6 = (byte) 0 ;
11601 byte arg7 = (byte) 0 ;
11602 bool result;
11603 byte temp2 ;
11604 int res2 = 0 ;
11605 byte temp3 ;
11606 int res3 = 0 ;
11607 byte temp4 ;
11608 int res4 = 0 ;
11609 PyObject * obj0 = 0 ;
11610 PyObject * obj1 = 0 ;
11611 PyObject * obj2 = 0 ;
11612 PyObject * obj3 = 0 ;
11613 char *kwnames[] = {
11614 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11615 };
11616
11617 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11618 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11619 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11622 if (SWIG_arg_fail(1)) SWIG_fail;
11623 if (obj1) {
11624 {
11625 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11626 if (SWIG_arg_fail(5)) SWIG_fail;
11627 }
11628 }
11629 if (obj2) {
11630 {
11631 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11632 if (SWIG_arg_fail(6)) SWIG_fail;
11633 }
11634 }
11635 if (obj3) {
11636 {
11637 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11638 if (SWIG_arg_fail(7)) SWIG_fail;
11639 }
11640 }
11641 {
11642 PyThreadState* __tstate = wxPyBeginAllowThreads();
11643 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11644
11645 wxPyEndAllowThreads(__tstate);
11646 if (PyErr_Occurred()) SWIG_fail;
11647 }
11648 {
11649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11650 }
11651 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11652 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11653 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11654 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11655 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11656 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11657 return resultobj;
11658 fail:
11659 return NULL;
11660 }
11661
11662
11663 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11664 PyObject *resultobj;
11665 wxImage *arg1 = (wxImage *) 0 ;
11666 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11667 bool result;
11668 PyObject * obj0 = 0 ;
11669 PyObject * obj1 = 0 ;
11670 char *kwnames[] = {
11671 (char *) "self",(char *) "threshold", NULL
11672 };
11673
11674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11676 if (SWIG_arg_fail(1)) SWIG_fail;
11677 if (obj1) {
11678 {
11679 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11680 if (SWIG_arg_fail(2)) SWIG_fail;
11681 }
11682 }
11683 {
11684 PyThreadState* __tstate = wxPyBeginAllowThreads();
11685 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11686
11687 wxPyEndAllowThreads(__tstate);
11688 if (PyErr_Occurred()) SWIG_fail;
11689 }
11690 {
11691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11692 }
11693 return resultobj;
11694 fail:
11695 return NULL;
11696 }
11697
11698
11699 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11700 PyObject *resultobj;
11701 wxImage *arg1 = (wxImage *) 0 ;
11702 byte arg2 ;
11703 byte arg3 ;
11704 byte arg4 ;
11705 bool result;
11706 PyObject * obj0 = 0 ;
11707 PyObject * obj1 = 0 ;
11708 PyObject * obj2 = 0 ;
11709 PyObject * obj3 = 0 ;
11710 char *kwnames[] = {
11711 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11712 };
11713
11714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11716 if (SWIG_arg_fail(1)) SWIG_fail;
11717 {
11718 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11719 if (SWIG_arg_fail(2)) SWIG_fail;
11720 }
11721 {
11722 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11723 if (SWIG_arg_fail(3)) SWIG_fail;
11724 }
11725 {
11726 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11727 if (SWIG_arg_fail(4)) SWIG_fail;
11728 }
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11732
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11738 }
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11746 PyObject *resultobj;
11747 wxImage *arg1 = (wxImage *) 0 ;
11748 wxImage *arg2 = 0 ;
11749 byte arg3 ;
11750 byte arg4 ;
11751 byte arg5 ;
11752 bool result;
11753 PyObject * obj0 = 0 ;
11754 PyObject * obj1 = 0 ;
11755 PyObject * obj2 = 0 ;
11756 PyObject * obj3 = 0 ;
11757 PyObject * obj4 = 0 ;
11758 char *kwnames[] = {
11759 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11760 };
11761
11762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11764 if (SWIG_arg_fail(1)) SWIG_fail;
11765 {
11766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11767 if (SWIG_arg_fail(2)) SWIG_fail;
11768 if (arg2 == NULL) {
11769 SWIG_null_ref("wxImage");
11770 }
11771 if (SWIG_arg_fail(2)) SWIG_fail;
11772 }
11773 {
11774 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11775 if (SWIG_arg_fail(3)) SWIG_fail;
11776 }
11777 {
11778 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11779 if (SWIG_arg_fail(4)) SWIG_fail;
11780 }
11781 {
11782 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11783 if (SWIG_arg_fail(5)) SWIG_fail;
11784 }
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11788
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11794 }
11795 return resultobj;
11796 fail:
11797 return NULL;
11798 }
11799
11800
11801 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11802 PyObject *resultobj;
11803 wxString *arg1 = 0 ;
11804 bool result;
11805 bool temp1 = false ;
11806 PyObject * obj0 = 0 ;
11807 char *kwnames[] = {
11808 (char *) "filename", NULL
11809 };
11810
11811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11812 {
11813 arg1 = wxString_in_helper(obj0);
11814 if (arg1 == NULL) SWIG_fail;
11815 temp1 = true;
11816 }
11817 {
11818 PyThreadState* __tstate = wxPyBeginAllowThreads();
11819 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11820
11821 wxPyEndAllowThreads(__tstate);
11822 if (PyErr_Occurred()) SWIG_fail;
11823 }
11824 {
11825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11826 }
11827 {
11828 if (temp1)
11829 delete arg1;
11830 }
11831 return resultobj;
11832 fail:
11833 {
11834 if (temp1)
11835 delete arg1;
11836 }
11837 return NULL;
11838 }
11839
11840
11841 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11842 PyObject *resultobj;
11843 wxString *arg1 = 0 ;
11844 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11845 int result;
11846 bool temp1 = false ;
11847 PyObject * obj0 = 0 ;
11848 PyObject * obj1 = 0 ;
11849 char *kwnames[] = {
11850 (char *) "filename",(char *) "type", NULL
11851 };
11852
11853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11854 {
11855 arg1 = wxString_in_helper(obj0);
11856 if (arg1 == NULL) SWIG_fail;
11857 temp1 = true;
11858 }
11859 if (obj1) {
11860 {
11861 arg2 = (long)(SWIG_As_long(obj1));
11862 if (SWIG_arg_fail(2)) SWIG_fail;
11863 }
11864 }
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11868
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 {
11873 resultobj = SWIG_From_int((int)(result));
11874 }
11875 {
11876 if (temp1)
11877 delete arg1;
11878 }
11879 return resultobj;
11880 fail:
11881 {
11882 if (temp1)
11883 delete arg1;
11884 }
11885 return NULL;
11886 }
11887
11888
11889 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11890 PyObject *resultobj;
11891 wxImage *arg1 = (wxImage *) 0 ;
11892 wxString *arg2 = 0 ;
11893 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11894 int arg4 = (int) -1 ;
11895 bool result;
11896 bool temp2 = false ;
11897 PyObject * obj0 = 0 ;
11898 PyObject * obj1 = 0 ;
11899 PyObject * obj2 = 0 ;
11900 PyObject * obj3 = 0 ;
11901 char *kwnames[] = {
11902 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11903 };
11904
11905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11907 if (SWIG_arg_fail(1)) SWIG_fail;
11908 {
11909 arg2 = wxString_in_helper(obj1);
11910 if (arg2 == NULL) SWIG_fail;
11911 temp2 = true;
11912 }
11913 if (obj2) {
11914 {
11915 arg3 = (long)(SWIG_As_long(obj2));
11916 if (SWIG_arg_fail(3)) SWIG_fail;
11917 }
11918 }
11919 if (obj3) {
11920 {
11921 arg4 = (int)(SWIG_As_int(obj3));
11922 if (SWIG_arg_fail(4)) SWIG_fail;
11923 }
11924 }
11925 {
11926 PyThreadState* __tstate = wxPyBeginAllowThreads();
11927 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11928
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 {
11933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11934 }
11935 {
11936 if (temp2)
11937 delete arg2;
11938 }
11939 return resultobj;
11940 fail:
11941 {
11942 if (temp2)
11943 delete arg2;
11944 }
11945 return NULL;
11946 }
11947
11948
11949 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11950 PyObject *resultobj;
11951 wxImage *arg1 = (wxImage *) 0 ;
11952 wxString *arg2 = 0 ;
11953 wxString *arg3 = 0 ;
11954 int arg4 = (int) -1 ;
11955 bool result;
11956 bool temp2 = false ;
11957 bool temp3 = false ;
11958 PyObject * obj0 = 0 ;
11959 PyObject * obj1 = 0 ;
11960 PyObject * obj2 = 0 ;
11961 PyObject * obj3 = 0 ;
11962 char *kwnames[] = {
11963 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11964 };
11965
11966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11968 if (SWIG_arg_fail(1)) SWIG_fail;
11969 {
11970 arg2 = wxString_in_helper(obj1);
11971 if (arg2 == NULL) SWIG_fail;
11972 temp2 = true;
11973 }
11974 {
11975 arg3 = wxString_in_helper(obj2);
11976 if (arg3 == NULL) SWIG_fail;
11977 temp3 = true;
11978 }
11979 if (obj3) {
11980 {
11981 arg4 = (int)(SWIG_As_int(obj3));
11982 if (SWIG_arg_fail(4)) SWIG_fail;
11983 }
11984 }
11985 {
11986 PyThreadState* __tstate = wxPyBeginAllowThreads();
11987 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11988
11989 wxPyEndAllowThreads(__tstate);
11990 if (PyErr_Occurred()) SWIG_fail;
11991 }
11992 {
11993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11994 }
11995 {
11996 if (temp2)
11997 delete arg2;
11998 }
11999 {
12000 if (temp3)
12001 delete arg3;
12002 }
12003 return resultobj;
12004 fail:
12005 {
12006 if (temp2)
12007 delete arg2;
12008 }
12009 {
12010 if (temp3)
12011 delete arg3;
12012 }
12013 return NULL;
12014 }
12015
12016
12017 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj;
12019 wxImage *arg1 = (wxImage *) 0 ;
12020 wxString *arg2 = 0 ;
12021 int arg3 ;
12022 bool result;
12023 bool temp2 = false ;
12024 PyObject * obj0 = 0 ;
12025 PyObject * obj1 = 0 ;
12026 PyObject * obj2 = 0 ;
12027 char *kwnames[] = {
12028 (char *) "self",(char *) "name",(char *) "type", NULL
12029 };
12030
12031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12033 if (SWIG_arg_fail(1)) SWIG_fail;
12034 {
12035 arg2 = wxString_in_helper(obj1);
12036 if (arg2 == NULL) SWIG_fail;
12037 temp2 = true;
12038 }
12039 {
12040 arg3 = (int)(SWIG_As_int(obj2));
12041 if (SWIG_arg_fail(3)) SWIG_fail;
12042 }
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12046
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 {
12051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12052 }
12053 {
12054 if (temp2)
12055 delete arg2;
12056 }
12057 return resultobj;
12058 fail:
12059 {
12060 if (temp2)
12061 delete arg2;
12062 }
12063 return NULL;
12064 }
12065
12066
12067 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12068 PyObject *resultobj;
12069 wxImage *arg1 = (wxImage *) 0 ;
12070 wxString *arg2 = 0 ;
12071 wxString *arg3 = 0 ;
12072 bool result;
12073 bool temp2 = false ;
12074 bool temp3 = false ;
12075 PyObject * obj0 = 0 ;
12076 PyObject * obj1 = 0 ;
12077 PyObject * obj2 = 0 ;
12078 char *kwnames[] = {
12079 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12080 };
12081
12082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12084 if (SWIG_arg_fail(1)) SWIG_fail;
12085 {
12086 arg2 = wxString_in_helper(obj1);
12087 if (arg2 == NULL) SWIG_fail;
12088 temp2 = true;
12089 }
12090 {
12091 arg3 = wxString_in_helper(obj2);
12092 if (arg3 == NULL) SWIG_fail;
12093 temp3 = true;
12094 }
12095 {
12096 PyThreadState* __tstate = wxPyBeginAllowThreads();
12097 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12098
12099 wxPyEndAllowThreads(__tstate);
12100 if (PyErr_Occurred()) SWIG_fail;
12101 }
12102 {
12103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12104 }
12105 {
12106 if (temp2)
12107 delete arg2;
12108 }
12109 {
12110 if (temp3)
12111 delete arg3;
12112 }
12113 return resultobj;
12114 fail:
12115 {
12116 if (temp2)
12117 delete arg2;
12118 }
12119 {
12120 if (temp3)
12121 delete arg3;
12122 }
12123 return NULL;
12124 }
12125
12126
12127 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12128 PyObject *resultobj;
12129 wxInputStream *arg1 = 0 ;
12130 bool result;
12131 wxPyInputStream *temp1 ;
12132 bool created1 ;
12133 PyObject * obj0 = 0 ;
12134 char *kwnames[] = {
12135 (char *) "stream", NULL
12136 };
12137
12138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12139 {
12140 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12141 arg1 = temp1->m_wxis;
12142 created1 = false;
12143 } else {
12144 PyErr_Clear(); // clear the failure of the wxPyConvert above
12145 arg1 = wxPyCBInputStream_create(obj0, false);
12146 if (arg1 == NULL) {
12147 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12148 SWIG_fail;
12149 }
12150 created1 = true;
12151 }
12152 }
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (bool)wxImage::CanRead(*arg1);
12156
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 {
12161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12162 }
12163 {
12164 if (created1) delete arg1;
12165 }
12166 return resultobj;
12167 fail:
12168 {
12169 if (created1) delete arg1;
12170 }
12171 return NULL;
12172 }
12173
12174
12175 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj;
12177 wxImage *arg1 = (wxImage *) 0 ;
12178 wxInputStream *arg2 = 0 ;
12179 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12180 int arg4 = (int) -1 ;
12181 bool result;
12182 wxPyInputStream *temp2 ;
12183 bool created2 ;
12184 PyObject * obj0 = 0 ;
12185 PyObject * obj1 = 0 ;
12186 PyObject * obj2 = 0 ;
12187 PyObject * obj3 = 0 ;
12188 char *kwnames[] = {
12189 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12190 };
12191
12192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12194 if (SWIG_arg_fail(1)) SWIG_fail;
12195 {
12196 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12197 arg2 = temp2->m_wxis;
12198 created2 = false;
12199 } else {
12200 PyErr_Clear(); // clear the failure of the wxPyConvert above
12201 arg2 = wxPyCBInputStream_create(obj1, false);
12202 if (arg2 == NULL) {
12203 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12204 SWIG_fail;
12205 }
12206 created2 = true;
12207 }
12208 }
12209 if (obj2) {
12210 {
12211 arg3 = (long)(SWIG_As_long(obj2));
12212 if (SWIG_arg_fail(3)) SWIG_fail;
12213 }
12214 }
12215 if (obj3) {
12216 {
12217 arg4 = (int)(SWIG_As_int(obj3));
12218 if (SWIG_arg_fail(4)) SWIG_fail;
12219 }
12220 }
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 {
12229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12230 }
12231 {
12232 if (created2) delete arg2;
12233 }
12234 return resultobj;
12235 fail:
12236 {
12237 if (created2) delete arg2;
12238 }
12239 return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj;
12245 wxImage *arg1 = (wxImage *) 0 ;
12246 wxInputStream *arg2 = 0 ;
12247 wxString *arg3 = 0 ;
12248 int arg4 = (int) -1 ;
12249 bool result;
12250 wxPyInputStream *temp2 ;
12251 bool created2 ;
12252 bool temp3 = false ;
12253 PyObject * obj0 = 0 ;
12254 PyObject * obj1 = 0 ;
12255 PyObject * obj2 = 0 ;
12256 PyObject * obj3 = 0 ;
12257 char *kwnames[] = {
12258 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12259 };
12260
12261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12266 arg2 = temp2->m_wxis;
12267 created2 = false;
12268 } else {
12269 PyErr_Clear(); // clear the failure of the wxPyConvert above
12270 arg2 = wxPyCBInputStream_create(obj1, false);
12271 if (arg2 == NULL) {
12272 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12273 SWIG_fail;
12274 }
12275 created2 = true;
12276 }
12277 }
12278 {
12279 arg3 = wxString_in_helper(obj2);
12280 if (arg3 == NULL) SWIG_fail;
12281 temp3 = true;
12282 }
12283 if (obj3) {
12284 {
12285 arg4 = (int)(SWIG_As_int(obj3));
12286 if (SWIG_arg_fail(4)) SWIG_fail;
12287 }
12288 }
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12292
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 {
12297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12298 }
12299 {
12300 if (created2) delete arg2;
12301 }
12302 {
12303 if (temp3)
12304 delete arg3;
12305 }
12306 return resultobj;
12307 fail:
12308 {
12309 if (created2) delete arg2;
12310 }
12311 {
12312 if (temp3)
12313 delete arg3;
12314 }
12315 return NULL;
12316 }
12317
12318
12319 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12320 PyObject *resultobj;
12321 wxImage *arg1 = (wxImage *) 0 ;
12322 bool result;
12323 PyObject * obj0 = 0 ;
12324 char *kwnames[] = {
12325 (char *) "self", NULL
12326 };
12327
12328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12330 if (SWIG_arg_fail(1)) SWIG_fail;
12331 {
12332 PyThreadState* __tstate = wxPyBeginAllowThreads();
12333 result = (bool)(arg1)->Ok();
12334
12335 wxPyEndAllowThreads(__tstate);
12336 if (PyErr_Occurred()) SWIG_fail;
12337 }
12338 {
12339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12340 }
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12348 PyObject *resultobj;
12349 wxImage *arg1 = (wxImage *) 0 ;
12350 int result;
12351 PyObject * obj0 = 0 ;
12352 char *kwnames[] = {
12353 (char *) "self", NULL
12354 };
12355
12356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12358 if (SWIG_arg_fail(1)) SWIG_fail;
12359 {
12360 PyThreadState* __tstate = wxPyBeginAllowThreads();
12361 result = (int)(arg1)->GetWidth();
12362
12363 wxPyEndAllowThreads(__tstate);
12364 if (PyErr_Occurred()) SWIG_fail;
12365 }
12366 {
12367 resultobj = SWIG_From_int((int)(result));
12368 }
12369 return resultobj;
12370 fail:
12371 return NULL;
12372 }
12373
12374
12375 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12376 PyObject *resultobj;
12377 wxImage *arg1 = (wxImage *) 0 ;
12378 int result;
12379 PyObject * obj0 = 0 ;
12380 char *kwnames[] = {
12381 (char *) "self", NULL
12382 };
12383
12384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12386 if (SWIG_arg_fail(1)) SWIG_fail;
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 result = (int)(arg1)->GetHeight();
12390
12391 wxPyEndAllowThreads(__tstate);
12392 if (PyErr_Occurred()) SWIG_fail;
12393 }
12394 {
12395 resultobj = SWIG_From_int((int)(result));
12396 }
12397 return resultobj;
12398 fail:
12399 return NULL;
12400 }
12401
12402
12403 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj;
12405 wxImage *arg1 = (wxImage *) 0 ;
12406 wxSize result;
12407 PyObject * obj0 = 0 ;
12408 char *kwnames[] = {
12409 (char *) "self", NULL
12410 };
12411
12412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12414 if (SWIG_arg_fail(1)) SWIG_fail;
12415 {
12416 PyThreadState* __tstate = wxPyBeginAllowThreads();
12417 result = wxImage_GetSize(arg1);
12418
12419 wxPyEndAllowThreads(__tstate);
12420 if (PyErr_Occurred()) SWIG_fail;
12421 }
12422 {
12423 wxSize * resultptr;
12424 resultptr = new wxSize((wxSize &)(result));
12425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12426 }
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj;
12435 wxImage *arg1 = (wxImage *) 0 ;
12436 wxRect *arg2 = 0 ;
12437 SwigValueWrapper<wxImage > result;
12438 wxRect temp2 ;
12439 PyObject * obj0 = 0 ;
12440 PyObject * obj1 = 0 ;
12441 char *kwnames[] = {
12442 (char *) "self",(char *) "rect", NULL
12443 };
12444
12445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12447 if (SWIG_arg_fail(1)) SWIG_fail;
12448 {
12449 arg2 = &temp2;
12450 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12455
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 {
12460 wxImage * resultptr;
12461 resultptr = new wxImage((wxImage &)(result));
12462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12463 }
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj;
12472 wxImage *arg1 = (wxImage *) 0 ;
12473 wxSize *arg2 = 0 ;
12474 wxPoint *arg3 = 0 ;
12475 int arg4 = (int) -1 ;
12476 int arg5 = (int) -1 ;
12477 int arg6 = (int) -1 ;
12478 SwigValueWrapper<wxImage > result;
12479 wxSize temp2 ;
12480 wxPoint temp3 ;
12481 PyObject * obj0 = 0 ;
12482 PyObject * obj1 = 0 ;
12483 PyObject * obj2 = 0 ;
12484 PyObject * obj3 = 0 ;
12485 PyObject * obj4 = 0 ;
12486 PyObject * obj5 = 0 ;
12487 char *kwnames[] = {
12488 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12489 };
12490
12491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12493 if (SWIG_arg_fail(1)) SWIG_fail;
12494 {
12495 arg2 = &temp2;
12496 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12497 }
12498 {
12499 arg3 = &temp3;
12500 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12501 }
12502 if (obj3) {
12503 {
12504 arg4 = (int)(SWIG_As_int(obj3));
12505 if (SWIG_arg_fail(4)) SWIG_fail;
12506 }
12507 }
12508 if (obj4) {
12509 {
12510 arg5 = (int)(SWIG_As_int(obj4));
12511 if (SWIG_arg_fail(5)) SWIG_fail;
12512 }
12513 }
12514 if (obj5) {
12515 {
12516 arg6 = (int)(SWIG_As_int(obj5));
12517 if (SWIG_arg_fail(6)) SWIG_fail;
12518 }
12519 }
12520 {
12521 PyThreadState* __tstate = wxPyBeginAllowThreads();
12522 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12523
12524 wxPyEndAllowThreads(__tstate);
12525 if (PyErr_Occurred()) SWIG_fail;
12526 }
12527 {
12528 wxImage * resultptr;
12529 resultptr = new wxImage((wxImage &)(result));
12530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12531 }
12532 return resultobj;
12533 fail:
12534 return NULL;
12535 }
12536
12537
12538 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12539 PyObject *resultobj;
12540 wxImage *arg1 = (wxImage *) 0 ;
12541 SwigValueWrapper<wxImage > result;
12542 PyObject * obj0 = 0 ;
12543 char *kwnames[] = {
12544 (char *) "self", NULL
12545 };
12546
12547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12549 if (SWIG_arg_fail(1)) SWIG_fail;
12550 {
12551 PyThreadState* __tstate = wxPyBeginAllowThreads();
12552 result = (arg1)->Copy();
12553
12554 wxPyEndAllowThreads(__tstate);
12555 if (PyErr_Occurred()) SWIG_fail;
12556 }
12557 {
12558 wxImage * resultptr;
12559 resultptr = new wxImage((wxImage &)(result));
12560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12561 }
12562 return resultobj;
12563 fail:
12564 return NULL;
12565 }
12566
12567
12568 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12569 PyObject *resultobj;
12570 wxImage *arg1 = (wxImage *) 0 ;
12571 wxImage *arg2 = 0 ;
12572 int arg3 ;
12573 int arg4 ;
12574 PyObject * obj0 = 0 ;
12575 PyObject * obj1 = 0 ;
12576 PyObject * obj2 = 0 ;
12577 PyObject * obj3 = 0 ;
12578 char *kwnames[] = {
12579 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12580 };
12581
12582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12584 if (SWIG_arg_fail(1)) SWIG_fail;
12585 {
12586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12587 if (SWIG_arg_fail(2)) SWIG_fail;
12588 if (arg2 == NULL) {
12589 SWIG_null_ref("wxImage");
12590 }
12591 if (SWIG_arg_fail(2)) SWIG_fail;
12592 }
12593 {
12594 arg3 = (int)(SWIG_As_int(obj2));
12595 if (SWIG_arg_fail(3)) SWIG_fail;
12596 }
12597 {
12598 arg4 = (int)(SWIG_As_int(obj3));
12599 if (SWIG_arg_fail(4)) SWIG_fail;
12600 }
12601 {
12602 PyThreadState* __tstate = wxPyBeginAllowThreads();
12603 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12604
12605 wxPyEndAllowThreads(__tstate);
12606 if (PyErr_Occurred()) SWIG_fail;
12607 }
12608 Py_INCREF(Py_None); resultobj = Py_None;
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12616 PyObject *resultobj;
12617 wxImage *arg1 = (wxImage *) 0 ;
12618 PyObject *result;
12619 PyObject * obj0 = 0 ;
12620 char *kwnames[] = {
12621 (char *) "self", NULL
12622 };
12623
12624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12626 if (SWIG_arg_fail(1)) SWIG_fail;
12627 {
12628 PyThreadState* __tstate = wxPyBeginAllowThreads();
12629 result = (PyObject *)wxImage_GetData(arg1);
12630
12631 wxPyEndAllowThreads(__tstate);
12632 if (PyErr_Occurred()) SWIG_fail;
12633 }
12634 resultobj = result;
12635 return resultobj;
12636 fail:
12637 return NULL;
12638 }
12639
12640
12641 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12642 PyObject *resultobj;
12643 wxImage *arg1 = (wxImage *) 0 ;
12644 buffer arg2 ;
12645 int arg3 ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 char *kwnames[] = {
12649 (char *) "self",(char *) "data", NULL
12650 };
12651
12652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12654 if (SWIG_arg_fail(1)) SWIG_fail;
12655 {
12656 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12657 }
12658 {
12659 PyThreadState* __tstate = wxPyBeginAllowThreads();
12660 wxImage_SetData(arg1,arg2,arg3);
12661
12662 wxPyEndAllowThreads(__tstate);
12663 if (PyErr_Occurred()) SWIG_fail;
12664 }
12665 Py_INCREF(Py_None); resultobj = Py_None;
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12673 PyObject *resultobj;
12674 wxImage *arg1 = (wxImage *) 0 ;
12675 PyObject *result;
12676 PyObject * obj0 = 0 ;
12677 char *kwnames[] = {
12678 (char *) "self", NULL
12679 };
12680
12681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12683 if (SWIG_arg_fail(1)) SWIG_fail;
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12687
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 resultobj = result;
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12699 PyObject *resultobj;
12700 wxImage *arg1 = (wxImage *) 0 ;
12701 buffer arg2 ;
12702 int arg3 ;
12703 PyObject * obj0 = 0 ;
12704 PyObject * obj1 = 0 ;
12705 char *kwnames[] = {
12706 (char *) "self",(char *) "data", NULL
12707 };
12708
12709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12711 if (SWIG_arg_fail(1)) SWIG_fail;
12712 {
12713 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12714 }
12715 {
12716 PyThreadState* __tstate = wxPyBeginAllowThreads();
12717 wxImage_SetDataBuffer(arg1,arg2,arg3);
12718
12719 wxPyEndAllowThreads(__tstate);
12720 if (PyErr_Occurred()) SWIG_fail;
12721 }
12722 Py_INCREF(Py_None); resultobj = Py_None;
12723 return resultobj;
12724 fail:
12725 return NULL;
12726 }
12727
12728
12729 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12730 PyObject *resultobj;
12731 wxImage *arg1 = (wxImage *) 0 ;
12732 PyObject *result;
12733 PyObject * obj0 = 0 ;
12734 char *kwnames[] = {
12735 (char *) "self", NULL
12736 };
12737
12738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12740 if (SWIG_arg_fail(1)) SWIG_fail;
12741 {
12742 PyThreadState* __tstate = wxPyBeginAllowThreads();
12743 result = (PyObject *)wxImage_GetAlphaData(arg1);
12744
12745 wxPyEndAllowThreads(__tstate);
12746 if (PyErr_Occurred()) SWIG_fail;
12747 }
12748 resultobj = result;
12749 return resultobj;
12750 fail:
12751 return NULL;
12752 }
12753
12754
12755 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12756 PyObject *resultobj;
12757 wxImage *arg1 = (wxImage *) 0 ;
12758 buffer arg2 ;
12759 int arg3 ;
12760 PyObject * obj0 = 0 ;
12761 PyObject * obj1 = 0 ;
12762 char *kwnames[] = {
12763 (char *) "self",(char *) "alpha", NULL
12764 };
12765
12766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12768 if (SWIG_arg_fail(1)) SWIG_fail;
12769 {
12770 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12771 }
12772 {
12773 PyThreadState* __tstate = wxPyBeginAllowThreads();
12774 wxImage_SetAlphaData(arg1,arg2,arg3);
12775
12776 wxPyEndAllowThreads(__tstate);
12777 if (PyErr_Occurred()) SWIG_fail;
12778 }
12779 Py_INCREF(Py_None); resultobj = Py_None;
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12787 PyObject *resultobj;
12788 wxImage *arg1 = (wxImage *) 0 ;
12789 PyObject *result;
12790 PyObject * obj0 = 0 ;
12791 char *kwnames[] = {
12792 (char *) "self", NULL
12793 };
12794
12795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12797 if (SWIG_arg_fail(1)) SWIG_fail;
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12801
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 resultobj = result;
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj;
12814 wxImage *arg1 = (wxImage *) 0 ;
12815 buffer arg2 ;
12816 int arg3 ;
12817 PyObject * obj0 = 0 ;
12818 PyObject * obj1 = 0 ;
12819 char *kwnames[] = {
12820 (char *) "self",(char *) "alpha", NULL
12821 };
12822
12823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12825 if (SWIG_arg_fail(1)) SWIG_fail;
12826 {
12827 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12828 }
12829 {
12830 PyThreadState* __tstate = wxPyBeginAllowThreads();
12831 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12832
12833 wxPyEndAllowThreads(__tstate);
12834 if (PyErr_Occurred()) SWIG_fail;
12835 }
12836 Py_INCREF(Py_None); resultobj = Py_None;
12837 return resultobj;
12838 fail:
12839 return NULL;
12840 }
12841
12842
12843 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12844 PyObject *resultobj;
12845 wxImage *arg1 = (wxImage *) 0 ;
12846 byte arg2 ;
12847 byte arg3 ;
12848 byte arg4 ;
12849 PyObject * obj0 = 0 ;
12850 PyObject * obj1 = 0 ;
12851 PyObject * obj2 = 0 ;
12852 PyObject * obj3 = 0 ;
12853 char *kwnames[] = {
12854 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12855 };
12856
12857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12859 if (SWIG_arg_fail(1)) SWIG_fail;
12860 {
12861 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12862 if (SWIG_arg_fail(2)) SWIG_fail;
12863 }
12864 {
12865 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12866 if (SWIG_arg_fail(3)) SWIG_fail;
12867 }
12868 {
12869 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12870 if (SWIG_arg_fail(4)) SWIG_fail;
12871 }
12872 {
12873 PyThreadState* __tstate = wxPyBeginAllowThreads();
12874 (arg1)->SetMaskColour(arg2,arg3,arg4);
12875
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 Py_INCREF(Py_None); resultobj = Py_None;
12880 return resultobj;
12881 fail:
12882 return NULL;
12883 }
12884
12885
12886 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12887 PyObject *resultobj;
12888 wxImage *arg1 = (wxImage *) 0 ;
12889 byte *arg2 = (byte *) 0 ;
12890 byte *arg3 = (byte *) 0 ;
12891 byte *arg4 = (byte *) 0 ;
12892 byte temp2 ;
12893 int res2 = 0 ;
12894 byte temp3 ;
12895 int res3 = 0 ;
12896 byte temp4 ;
12897 int res4 = 0 ;
12898 PyObject * obj0 = 0 ;
12899 char *kwnames[] = {
12900 (char *) "self", NULL
12901 };
12902
12903 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12904 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12905 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12908 if (SWIG_arg_fail(1)) SWIG_fail;
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12912
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 Py_INCREF(Py_None); resultobj = Py_None;
12917 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12918 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12919 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12920 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12921 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12922 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12923 return resultobj;
12924 fail:
12925 return NULL;
12926 }
12927
12928
12929 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12930 PyObject *resultobj;
12931 wxImage *arg1 = (wxImage *) 0 ;
12932 byte result;
12933 PyObject * obj0 = 0 ;
12934 char *kwnames[] = {
12935 (char *) "self", NULL
12936 };
12937
12938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12940 if (SWIG_arg_fail(1)) SWIG_fail;
12941 {
12942 PyThreadState* __tstate = wxPyBeginAllowThreads();
12943 result = (byte)(arg1)->GetMaskRed();
12944
12945 wxPyEndAllowThreads(__tstate);
12946 if (PyErr_Occurred()) SWIG_fail;
12947 }
12948 {
12949 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12950 }
12951 return resultobj;
12952 fail:
12953 return NULL;
12954 }
12955
12956
12957 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12958 PyObject *resultobj;
12959 wxImage *arg1 = (wxImage *) 0 ;
12960 byte result;
12961 PyObject * obj0 = 0 ;
12962 char *kwnames[] = {
12963 (char *) "self", NULL
12964 };
12965
12966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12968 if (SWIG_arg_fail(1)) SWIG_fail;
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 result = (byte)(arg1)->GetMaskGreen();
12972
12973 wxPyEndAllowThreads(__tstate);
12974 if (PyErr_Occurred()) SWIG_fail;
12975 }
12976 {
12977 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12978 }
12979 return resultobj;
12980 fail:
12981 return NULL;
12982 }
12983
12984
12985 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12986 PyObject *resultobj;
12987 wxImage *arg1 = (wxImage *) 0 ;
12988 byte result;
12989 PyObject * obj0 = 0 ;
12990 char *kwnames[] = {
12991 (char *) "self", NULL
12992 };
12993
12994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12996 if (SWIG_arg_fail(1)) SWIG_fail;
12997 {
12998 PyThreadState* __tstate = wxPyBeginAllowThreads();
12999 result = (byte)(arg1)->GetMaskBlue();
13000
13001 wxPyEndAllowThreads(__tstate);
13002 if (PyErr_Occurred()) SWIG_fail;
13003 }
13004 {
13005 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13006 }
13007 return resultobj;
13008 fail:
13009 return NULL;
13010 }
13011
13012
13013 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13014 PyObject *resultobj;
13015 wxImage *arg1 = (wxImage *) 0 ;
13016 bool arg2 = (bool) true ;
13017 PyObject * obj0 = 0 ;
13018 PyObject * obj1 = 0 ;
13019 char *kwnames[] = {
13020 (char *) "self",(char *) "mask", NULL
13021 };
13022
13023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13025 if (SWIG_arg_fail(1)) SWIG_fail;
13026 if (obj1) {
13027 {
13028 arg2 = (bool)(SWIG_As_bool(obj1));
13029 if (SWIG_arg_fail(2)) SWIG_fail;
13030 }
13031 }
13032 {
13033 PyThreadState* __tstate = wxPyBeginAllowThreads();
13034 (arg1)->SetMask(arg2);
13035
13036 wxPyEndAllowThreads(__tstate);
13037 if (PyErr_Occurred()) SWIG_fail;
13038 }
13039 Py_INCREF(Py_None); resultobj = Py_None;
13040 return resultobj;
13041 fail:
13042 return NULL;
13043 }
13044
13045
13046 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13047 PyObject *resultobj;
13048 wxImage *arg1 = (wxImage *) 0 ;
13049 bool result;
13050 PyObject * obj0 = 0 ;
13051 char *kwnames[] = {
13052 (char *) "self", NULL
13053 };
13054
13055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13057 if (SWIG_arg_fail(1)) SWIG_fail;
13058 {
13059 PyThreadState* __tstate = wxPyBeginAllowThreads();
13060 result = (bool)(arg1)->HasMask();
13061
13062 wxPyEndAllowThreads(__tstate);
13063 if (PyErr_Occurred()) SWIG_fail;
13064 }
13065 {
13066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13067 }
13068 return resultobj;
13069 fail:
13070 return NULL;
13071 }
13072
13073
13074 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13075 PyObject *resultobj;
13076 wxImage *arg1 = (wxImage *) 0 ;
13077 double arg2 ;
13078 wxPoint *arg3 = 0 ;
13079 bool arg4 = (bool) true ;
13080 wxPoint *arg5 = (wxPoint *) NULL ;
13081 SwigValueWrapper<wxImage > result;
13082 wxPoint temp3 ;
13083 PyObject * obj0 = 0 ;
13084 PyObject * obj1 = 0 ;
13085 PyObject * obj2 = 0 ;
13086 PyObject * obj3 = 0 ;
13087 PyObject * obj4 = 0 ;
13088 char *kwnames[] = {
13089 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13090 };
13091
13092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13094 if (SWIG_arg_fail(1)) SWIG_fail;
13095 {
13096 arg2 = (double)(SWIG_As_double(obj1));
13097 if (SWIG_arg_fail(2)) SWIG_fail;
13098 }
13099 {
13100 arg3 = &temp3;
13101 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13102 }
13103 if (obj3) {
13104 {
13105 arg4 = (bool)(SWIG_As_bool(obj3));
13106 if (SWIG_arg_fail(4)) SWIG_fail;
13107 }
13108 }
13109 if (obj4) {
13110 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13111 if (SWIG_arg_fail(5)) SWIG_fail;
13112 }
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13116
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 {
13121 wxImage * resultptr;
13122 resultptr = new wxImage((wxImage &)(result));
13123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13124 }
13125 return resultobj;
13126 fail:
13127 return NULL;
13128 }
13129
13130
13131 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13132 PyObject *resultobj;
13133 wxImage *arg1 = (wxImage *) 0 ;
13134 bool arg2 = (bool) true ;
13135 SwigValueWrapper<wxImage > result;
13136 PyObject * obj0 = 0 ;
13137 PyObject * obj1 = 0 ;
13138 char *kwnames[] = {
13139 (char *) "self",(char *) "clockwise", NULL
13140 };
13141
13142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13144 if (SWIG_arg_fail(1)) SWIG_fail;
13145 if (obj1) {
13146 {
13147 arg2 = (bool)(SWIG_As_bool(obj1));
13148 if (SWIG_arg_fail(2)) SWIG_fail;
13149 }
13150 }
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (arg1)->Rotate90(arg2);
13154
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 {
13159 wxImage * resultptr;
13160 resultptr = new wxImage((wxImage &)(result));
13161 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13162 }
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj;
13171 wxImage *arg1 = (wxImage *) 0 ;
13172 bool arg2 = (bool) true ;
13173 SwigValueWrapper<wxImage > result;
13174 PyObject * obj0 = 0 ;
13175 PyObject * obj1 = 0 ;
13176 char *kwnames[] = {
13177 (char *) "self",(char *) "horizontally", NULL
13178 };
13179
13180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13182 if (SWIG_arg_fail(1)) SWIG_fail;
13183 if (obj1) {
13184 {
13185 arg2 = (bool)(SWIG_As_bool(obj1));
13186 if (SWIG_arg_fail(2)) SWIG_fail;
13187 }
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 result = (arg1)->Mirror(arg2);
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 {
13197 wxImage * resultptr;
13198 resultptr = new wxImage((wxImage &)(result));
13199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13200 }
13201 return resultobj;
13202 fail:
13203 return NULL;
13204 }
13205
13206
13207 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13208 PyObject *resultobj;
13209 wxImage *arg1 = (wxImage *) 0 ;
13210 byte arg2 ;
13211 byte arg3 ;
13212 byte arg4 ;
13213 byte arg5 ;
13214 byte arg6 ;
13215 byte arg7 ;
13216 PyObject * obj0 = 0 ;
13217 PyObject * obj1 = 0 ;
13218 PyObject * obj2 = 0 ;
13219 PyObject * obj3 = 0 ;
13220 PyObject * obj4 = 0 ;
13221 PyObject * obj5 = 0 ;
13222 PyObject * obj6 = 0 ;
13223 char *kwnames[] = {
13224 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13225 };
13226
13227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13229 if (SWIG_arg_fail(1)) SWIG_fail;
13230 {
13231 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13232 if (SWIG_arg_fail(2)) SWIG_fail;
13233 }
13234 {
13235 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13236 if (SWIG_arg_fail(3)) SWIG_fail;
13237 }
13238 {
13239 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13240 if (SWIG_arg_fail(4)) SWIG_fail;
13241 }
13242 {
13243 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13244 if (SWIG_arg_fail(5)) SWIG_fail;
13245 }
13246 {
13247 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13248 if (SWIG_arg_fail(6)) SWIG_fail;
13249 }
13250 {
13251 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13252 if (SWIG_arg_fail(7)) SWIG_fail;
13253 }
13254 {
13255 PyThreadState* __tstate = wxPyBeginAllowThreads();
13256 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13257
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 Py_INCREF(Py_None); resultobj = Py_None;
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13269 PyObject *resultobj;
13270 wxImage *arg1 = (wxImage *) 0 ;
13271 byte arg2 ;
13272 byte arg3 ;
13273 byte arg4 ;
13274 SwigValueWrapper<wxImage > result;
13275 PyObject * obj0 = 0 ;
13276 PyObject * obj1 = 0 ;
13277 PyObject * obj2 = 0 ;
13278 PyObject * obj3 = 0 ;
13279 char *kwnames[] = {
13280 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13281 };
13282
13283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13285 if (SWIG_arg_fail(1)) SWIG_fail;
13286 {
13287 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13288 if (SWIG_arg_fail(2)) SWIG_fail;
13289 }
13290 {
13291 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13292 if (SWIG_arg_fail(3)) SWIG_fail;
13293 }
13294 {
13295 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13296 if (SWIG_arg_fail(4)) SWIG_fail;
13297 }
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13301
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 {
13306 wxImage * resultptr;
13307 resultptr = new wxImage((wxImage &)(result));
13308 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13309 }
13310 return resultobj;
13311 fail:
13312 return NULL;
13313 }
13314
13315
13316 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13317 PyObject *resultobj;
13318 wxImage *arg1 = (wxImage *) 0 ;
13319 wxString *arg2 = 0 ;
13320 wxString *arg3 = 0 ;
13321 bool temp2 = false ;
13322 bool temp3 = false ;
13323 PyObject * obj0 = 0 ;
13324 PyObject * obj1 = 0 ;
13325 PyObject * obj2 = 0 ;
13326 char *kwnames[] = {
13327 (char *) "self",(char *) "name",(char *) "value", NULL
13328 };
13329
13330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) 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 = wxString_in_helper(obj1);
13335 if (arg2 == NULL) SWIG_fail;
13336 temp2 = true;
13337 }
13338 {
13339 arg3 = wxString_in_helper(obj2);
13340 if (arg3 == NULL) SWIG_fail;
13341 temp3 = true;
13342 }
13343 {
13344 PyThreadState* __tstate = wxPyBeginAllowThreads();
13345 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13346
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 Py_INCREF(Py_None); resultobj = Py_None;
13351 {
13352 if (temp2)
13353 delete arg2;
13354 }
13355 {
13356 if (temp3)
13357 delete arg3;
13358 }
13359 return resultobj;
13360 fail:
13361 {
13362 if (temp2)
13363 delete arg2;
13364 }
13365 {
13366 if (temp3)
13367 delete arg3;
13368 }
13369 return NULL;
13370 }
13371
13372
13373 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13374 PyObject *resultobj;
13375 wxImage *arg1 = (wxImage *) 0 ;
13376 wxString *arg2 = 0 ;
13377 int arg3 ;
13378 bool temp2 = false ;
13379 PyObject * obj0 = 0 ;
13380 PyObject * obj1 = 0 ;
13381 PyObject * obj2 = 0 ;
13382 char *kwnames[] = {
13383 (char *) "self",(char *) "name",(char *) "value", NULL
13384 };
13385
13386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13388 if (SWIG_arg_fail(1)) SWIG_fail;
13389 {
13390 arg2 = wxString_in_helper(obj1);
13391 if (arg2 == NULL) SWIG_fail;
13392 temp2 = true;
13393 }
13394 {
13395 arg3 = (int)(SWIG_As_int(obj2));
13396 if (SWIG_arg_fail(3)) SWIG_fail;
13397 }
13398 {
13399 PyThreadState* __tstate = wxPyBeginAllowThreads();
13400 (arg1)->SetOption((wxString const &)*arg2,arg3);
13401
13402 wxPyEndAllowThreads(__tstate);
13403 if (PyErr_Occurred()) SWIG_fail;
13404 }
13405 Py_INCREF(Py_None); resultobj = Py_None;
13406 {
13407 if (temp2)
13408 delete arg2;
13409 }
13410 return resultobj;
13411 fail:
13412 {
13413 if (temp2)
13414 delete arg2;
13415 }
13416 return NULL;
13417 }
13418
13419
13420 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13421 PyObject *resultobj;
13422 wxImage *arg1 = (wxImage *) 0 ;
13423 wxString *arg2 = 0 ;
13424 wxString result;
13425 bool temp2 = false ;
13426 PyObject * obj0 = 0 ;
13427 PyObject * obj1 = 0 ;
13428 char *kwnames[] = {
13429 (char *) "self",(char *) "name", NULL
13430 };
13431
13432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13434 if (SWIG_arg_fail(1)) SWIG_fail;
13435 {
13436 arg2 = wxString_in_helper(obj1);
13437 if (arg2 == NULL) SWIG_fail;
13438 temp2 = true;
13439 }
13440 {
13441 PyThreadState* __tstate = wxPyBeginAllowThreads();
13442 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13443
13444 wxPyEndAllowThreads(__tstate);
13445 if (PyErr_Occurred()) SWIG_fail;
13446 }
13447 {
13448 #if wxUSE_UNICODE
13449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13450 #else
13451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13452 #endif
13453 }
13454 {
13455 if (temp2)
13456 delete arg2;
13457 }
13458 return resultobj;
13459 fail:
13460 {
13461 if (temp2)
13462 delete arg2;
13463 }
13464 return NULL;
13465 }
13466
13467
13468 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13469 PyObject *resultobj;
13470 wxImage *arg1 = (wxImage *) 0 ;
13471 wxString *arg2 = 0 ;
13472 int result;
13473 bool temp2 = false ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 char *kwnames[] = {
13477 (char *) "self",(char *) "name", NULL
13478 };
13479
13480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13482 if (SWIG_arg_fail(1)) SWIG_fail;
13483 {
13484 arg2 = wxString_in_helper(obj1);
13485 if (arg2 == NULL) SWIG_fail;
13486 temp2 = true;
13487 }
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13491
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 {
13496 resultobj = SWIG_From_int((int)(result));
13497 }
13498 {
13499 if (temp2)
13500 delete arg2;
13501 }
13502 return resultobj;
13503 fail:
13504 {
13505 if (temp2)
13506 delete arg2;
13507 }
13508 return NULL;
13509 }
13510
13511
13512 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13513 PyObject *resultobj;
13514 wxImage *arg1 = (wxImage *) 0 ;
13515 wxString *arg2 = 0 ;
13516 bool result;
13517 bool temp2 = false ;
13518 PyObject * obj0 = 0 ;
13519 PyObject * obj1 = 0 ;
13520 char *kwnames[] = {
13521 (char *) "self",(char *) "name", NULL
13522 };
13523
13524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13526 if (SWIG_arg_fail(1)) SWIG_fail;
13527 {
13528 arg2 = wxString_in_helper(obj1);
13529 if (arg2 == NULL) SWIG_fail;
13530 temp2 = true;
13531 }
13532 {
13533 PyThreadState* __tstate = wxPyBeginAllowThreads();
13534 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13535
13536 wxPyEndAllowThreads(__tstate);
13537 if (PyErr_Occurred()) SWIG_fail;
13538 }
13539 {
13540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13541 }
13542 {
13543 if (temp2)
13544 delete arg2;
13545 }
13546 return resultobj;
13547 fail:
13548 {
13549 if (temp2)
13550 delete arg2;
13551 }
13552 return NULL;
13553 }
13554
13555
13556 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13557 PyObject *resultobj;
13558 wxImage *arg1 = (wxImage *) 0 ;
13559 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13560 unsigned long result;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 char *kwnames[] = {
13564 (char *) "self",(char *) "stopafter", NULL
13565 };
13566
13567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13569 if (SWIG_arg_fail(1)) SWIG_fail;
13570 if (obj1) {
13571 {
13572 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13573 if (SWIG_arg_fail(2)) SWIG_fail;
13574 }
13575 }
13576 {
13577 PyThreadState* __tstate = wxPyBeginAllowThreads();
13578 result = (unsigned long)(arg1)->CountColours(arg2);
13579
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 {
13584 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13585 }
13586 return resultobj;
13587 fail:
13588 return NULL;
13589 }
13590
13591
13592 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13593 PyObject *resultobj;
13594 wxImage *arg1 = (wxImage *) 0 ;
13595 wxImageHistogram *arg2 = 0 ;
13596 unsigned long result;
13597 PyObject * obj0 = 0 ;
13598 PyObject * obj1 = 0 ;
13599 char *kwnames[] = {
13600 (char *) "self",(char *) "h", NULL
13601 };
13602
13603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13605 if (SWIG_arg_fail(1)) SWIG_fail;
13606 {
13607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13608 if (SWIG_arg_fail(2)) SWIG_fail;
13609 if (arg2 == NULL) {
13610 SWIG_null_ref("wxImageHistogram");
13611 }
13612 if (SWIG_arg_fail(2)) SWIG_fail;
13613 }
13614 {
13615 PyThreadState* __tstate = wxPyBeginAllowThreads();
13616 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13617
13618 wxPyEndAllowThreads(__tstate);
13619 if (PyErr_Occurred()) SWIG_fail;
13620 }
13621 {
13622 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13623 }
13624 return resultobj;
13625 fail:
13626 return NULL;
13627 }
13628
13629
13630 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13631 PyObject *resultobj;
13632 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13633 PyObject * obj0 = 0 ;
13634 char *kwnames[] = {
13635 (char *) "handler", NULL
13636 };
13637
13638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13640 if (SWIG_arg_fail(1)) SWIG_fail;
13641 {
13642 PyThreadState* __tstate = wxPyBeginAllowThreads();
13643 wxImage::AddHandler(arg1);
13644
13645 wxPyEndAllowThreads(__tstate);
13646 if (PyErr_Occurred()) SWIG_fail;
13647 }
13648 Py_INCREF(Py_None); resultobj = Py_None;
13649 return resultobj;
13650 fail:
13651 return NULL;
13652 }
13653
13654
13655 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13656 PyObject *resultobj;
13657 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13658 PyObject * obj0 = 0 ;
13659 char *kwnames[] = {
13660 (char *) "handler", NULL
13661 };
13662
13663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13665 if (SWIG_arg_fail(1)) SWIG_fail;
13666 {
13667 PyThreadState* __tstate = wxPyBeginAllowThreads();
13668 wxImage::InsertHandler(arg1);
13669
13670 wxPyEndAllowThreads(__tstate);
13671 if (PyErr_Occurred()) SWIG_fail;
13672 }
13673 Py_INCREF(Py_None); resultobj = Py_None;
13674 return resultobj;
13675 fail:
13676 return NULL;
13677 }
13678
13679
13680 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13681 PyObject *resultobj;
13682 wxString *arg1 = 0 ;
13683 bool result;
13684 bool temp1 = false ;
13685 PyObject * obj0 = 0 ;
13686 char *kwnames[] = {
13687 (char *) "name", NULL
13688 };
13689
13690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13691 {
13692 arg1 = wxString_in_helper(obj0);
13693 if (arg1 == NULL) SWIG_fail;
13694 temp1 = true;
13695 }
13696 {
13697 PyThreadState* __tstate = wxPyBeginAllowThreads();
13698 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13699
13700 wxPyEndAllowThreads(__tstate);
13701 if (PyErr_Occurred()) SWIG_fail;
13702 }
13703 {
13704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13705 }
13706 {
13707 if (temp1)
13708 delete arg1;
13709 }
13710 return resultobj;
13711 fail:
13712 {
13713 if (temp1)
13714 delete arg1;
13715 }
13716 return NULL;
13717 }
13718
13719
13720 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13721 PyObject *resultobj;
13722 wxString result;
13723 char *kwnames[] = {
13724 NULL
13725 };
13726
13727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13728 {
13729 PyThreadState* __tstate = wxPyBeginAllowThreads();
13730 result = wxImage::GetImageExtWildcard();
13731
13732 wxPyEndAllowThreads(__tstate);
13733 if (PyErr_Occurred()) SWIG_fail;
13734 }
13735 {
13736 #if wxUSE_UNICODE
13737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13738 #else
13739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13740 #endif
13741 }
13742 return resultobj;
13743 fail:
13744 return NULL;
13745 }
13746
13747
13748 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13749 PyObject *resultobj;
13750 wxImage *arg1 = (wxImage *) 0 ;
13751 int arg2 = (int) -1 ;
13752 wxBitmap result;
13753 PyObject * obj0 = 0 ;
13754 PyObject * obj1 = 0 ;
13755 char *kwnames[] = {
13756 (char *) "self",(char *) "depth", NULL
13757 };
13758
13759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13761 if (SWIG_arg_fail(1)) SWIG_fail;
13762 if (obj1) {
13763 {
13764 arg2 = (int)(SWIG_As_int(obj1));
13765 if (SWIG_arg_fail(2)) SWIG_fail;
13766 }
13767 }
13768 {
13769 if (!wxPyCheckForApp()) SWIG_fail;
13770 PyThreadState* __tstate = wxPyBeginAllowThreads();
13771 result = wxImage_ConvertToBitmap(arg1,arg2);
13772
13773 wxPyEndAllowThreads(__tstate);
13774 if (PyErr_Occurred()) SWIG_fail;
13775 }
13776 {
13777 wxBitmap * resultptr;
13778 resultptr = new wxBitmap((wxBitmap &)(result));
13779 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13780 }
13781 return resultobj;
13782 fail:
13783 return NULL;
13784 }
13785
13786
13787 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13788 PyObject *resultobj;
13789 wxImage *arg1 = (wxImage *) 0 ;
13790 byte arg2 ;
13791 byte arg3 ;
13792 byte arg4 ;
13793 wxBitmap result;
13794 PyObject * obj0 = 0 ;
13795 PyObject * obj1 = 0 ;
13796 PyObject * obj2 = 0 ;
13797 PyObject * obj3 = 0 ;
13798 char *kwnames[] = {
13799 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13800 };
13801
13802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13804 if (SWIG_arg_fail(1)) SWIG_fail;
13805 {
13806 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13807 if (SWIG_arg_fail(2)) SWIG_fail;
13808 }
13809 {
13810 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13811 if (SWIG_arg_fail(3)) SWIG_fail;
13812 }
13813 {
13814 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13815 if (SWIG_arg_fail(4)) SWIG_fail;
13816 }
13817 {
13818 if (!wxPyCheckForApp()) SWIG_fail;
13819 PyThreadState* __tstate = wxPyBeginAllowThreads();
13820 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13821
13822 wxPyEndAllowThreads(__tstate);
13823 if (PyErr_Occurred()) SWIG_fail;
13824 }
13825 {
13826 wxBitmap * resultptr;
13827 resultptr = new wxBitmap((wxBitmap &)(result));
13828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13829 }
13830 return resultobj;
13831 fail:
13832 return NULL;
13833 }
13834
13835
13836 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13837 PyObject *obj;
13838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13839 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13840 Py_INCREF(obj);
13841 return Py_BuildValue((char *)"");
13842 }
13843 static int _wrap_NullImage_set(PyObject *) {
13844 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13845 return 1;
13846 }
13847
13848
13849 static PyObject *_wrap_NullImage_get(void) {
13850 PyObject *pyobj;
13851
13852 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13853 return pyobj;
13854 }
13855
13856
13857 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13858 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13859 return 1;
13860 }
13861
13862
13863 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13864 PyObject *pyobj;
13865
13866 {
13867 #if wxUSE_UNICODE
13868 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13869 #else
13870 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13871 #endif
13872 }
13873 return pyobj;
13874 }
13875
13876
13877 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13878 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13879 return 1;
13880 }
13881
13882
13883 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13884 PyObject *pyobj;
13885
13886 {
13887 #if wxUSE_UNICODE
13888 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13889 #else
13890 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13891 #endif
13892 }
13893 return pyobj;
13894 }
13895
13896
13897 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13898 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13899 return 1;
13900 }
13901
13902
13903 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13904 PyObject *pyobj;
13905
13906 {
13907 #if wxUSE_UNICODE
13908 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13909 #else
13910 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13911 #endif
13912 }
13913 return pyobj;
13914 }
13915
13916
13917 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13918 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13919 return 1;
13920 }
13921
13922
13923 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13924 PyObject *pyobj;
13925
13926 {
13927 #if wxUSE_UNICODE
13928 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13929 #else
13930 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13931 #endif
13932 }
13933 return pyobj;
13934 }
13935
13936
13937 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13938 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13939 return 1;
13940 }
13941
13942
13943 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13944 PyObject *pyobj;
13945
13946 {
13947 #if wxUSE_UNICODE
13948 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13949 #else
13950 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13951 #endif
13952 }
13953 return pyobj;
13954 }
13955
13956
13957 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13958 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13959 return 1;
13960 }
13961
13962
13963 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13964 PyObject *pyobj;
13965
13966 {
13967 #if wxUSE_UNICODE
13968 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13969 #else
13970 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13971 #endif
13972 }
13973 return pyobj;
13974 }
13975
13976
13977 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13978 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13979 return 1;
13980 }
13981
13982
13983 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13984 PyObject *pyobj;
13985
13986 {
13987 #if wxUSE_UNICODE
13988 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13989 #else
13990 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13991 #endif
13992 }
13993 return pyobj;
13994 }
13995
13996
13997 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13998 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13999 return 1;
14000 }
14001
14002
14003 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14004 PyObject *pyobj;
14005
14006 {
14007 #if wxUSE_UNICODE
14008 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14009 #else
14010 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14011 #endif
14012 }
14013 return pyobj;
14014 }
14015
14016
14017 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14018 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14019 return 1;
14020 }
14021
14022
14023 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14024 PyObject *pyobj;
14025
14026 {
14027 #if wxUSE_UNICODE
14028 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14029 #else
14030 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14031 #endif
14032 }
14033 return pyobj;
14034 }
14035
14036
14037 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14038 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14039 return 1;
14040 }
14041
14042
14043 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14044 PyObject *pyobj;
14045
14046 {
14047 #if wxUSE_UNICODE
14048 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14049 #else
14050 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14051 #endif
14052 }
14053 return pyobj;
14054 }
14055
14056
14057 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14058 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14059 return 1;
14060 }
14061
14062
14063 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14064 PyObject *pyobj;
14065
14066 {
14067 #if wxUSE_UNICODE
14068 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14069 #else
14070 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14071 #endif
14072 }
14073 return pyobj;
14074 }
14075
14076
14077 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14078 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14079 return 1;
14080 }
14081
14082
14083 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14084 PyObject *pyobj;
14085
14086 {
14087 #if wxUSE_UNICODE
14088 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14089 #else
14090 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14091 #endif
14092 }
14093 return pyobj;
14094 }
14095
14096
14097 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14098 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14099 return 1;
14100 }
14101
14102
14103 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14104 PyObject *pyobj;
14105
14106 {
14107 #if wxUSE_UNICODE
14108 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14109 #else
14110 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14111 #endif
14112 }
14113 return pyobj;
14114 }
14115
14116
14117 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14118 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14119 return 1;
14120 }
14121
14122
14123 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14124 PyObject *pyobj;
14125
14126 {
14127 #if wxUSE_UNICODE
14128 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14129 #else
14130 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14131 #endif
14132 }
14133 return pyobj;
14134 }
14135
14136
14137 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14138 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14139 return 1;
14140 }
14141
14142
14143 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14144 PyObject *pyobj;
14145
14146 {
14147 #if wxUSE_UNICODE
14148 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14149 #else
14150 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14151 #endif
14152 }
14153 return pyobj;
14154 }
14155
14156
14157 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj;
14159 wxBMPHandler *result;
14160 char *kwnames[] = {
14161 NULL
14162 };
14163
14164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 result = (wxBMPHandler *)new wxBMPHandler();
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14180 PyObject *obj;
14181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14182 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14183 Py_INCREF(obj);
14184 return Py_BuildValue((char *)"");
14185 }
14186 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14187 PyObject *resultobj;
14188 wxICOHandler *result;
14189 char *kwnames[] = {
14190 NULL
14191 };
14192
14193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14194 {
14195 PyThreadState* __tstate = wxPyBeginAllowThreads();
14196 result = (wxICOHandler *)new wxICOHandler();
14197
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14209 PyObject *obj;
14210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14211 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14212 Py_INCREF(obj);
14213 return Py_BuildValue((char *)"");
14214 }
14215 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14216 PyObject *resultobj;
14217 wxCURHandler *result;
14218 char *kwnames[] = {
14219 NULL
14220 };
14221
14222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14223 {
14224 PyThreadState* __tstate = wxPyBeginAllowThreads();
14225 result = (wxCURHandler *)new wxCURHandler();
14226
14227 wxPyEndAllowThreads(__tstate);
14228 if (PyErr_Occurred()) SWIG_fail;
14229 }
14230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14231 return resultobj;
14232 fail:
14233 return NULL;
14234 }
14235
14236
14237 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14238 PyObject *obj;
14239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14240 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14241 Py_INCREF(obj);
14242 return Py_BuildValue((char *)"");
14243 }
14244 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj;
14246 wxANIHandler *result;
14247 char *kwnames[] = {
14248 NULL
14249 };
14250
14251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14252 {
14253 PyThreadState* __tstate = wxPyBeginAllowThreads();
14254 result = (wxANIHandler *)new wxANIHandler();
14255
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14260 return resultobj;
14261 fail:
14262 return NULL;
14263 }
14264
14265
14266 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14267 PyObject *obj;
14268 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14269 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14270 Py_INCREF(obj);
14271 return Py_BuildValue((char *)"");
14272 }
14273 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14274 PyObject *resultobj;
14275 wxPNGHandler *result;
14276 char *kwnames[] = {
14277 NULL
14278 };
14279
14280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 result = (wxPNGHandler *)new wxPNGHandler();
14284
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14296 PyObject *obj;
14297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14298 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14299 Py_INCREF(obj);
14300 return Py_BuildValue((char *)"");
14301 }
14302 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14303 PyObject *resultobj;
14304 wxGIFHandler *result;
14305 char *kwnames[] = {
14306 NULL
14307 };
14308
14309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14310 {
14311 PyThreadState* __tstate = wxPyBeginAllowThreads();
14312 result = (wxGIFHandler *)new wxGIFHandler();
14313
14314 wxPyEndAllowThreads(__tstate);
14315 if (PyErr_Occurred()) SWIG_fail;
14316 }
14317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14318 return resultobj;
14319 fail:
14320 return NULL;
14321 }
14322
14323
14324 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14325 PyObject *obj;
14326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14327 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14328 Py_INCREF(obj);
14329 return Py_BuildValue((char *)"");
14330 }
14331 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14332 PyObject *resultobj;
14333 wxPCXHandler *result;
14334 char *kwnames[] = {
14335 NULL
14336 };
14337
14338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14339 {
14340 PyThreadState* __tstate = wxPyBeginAllowThreads();
14341 result = (wxPCXHandler *)new wxPCXHandler();
14342
14343 wxPyEndAllowThreads(__tstate);
14344 if (PyErr_Occurred()) SWIG_fail;
14345 }
14346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14347 return resultobj;
14348 fail:
14349 return NULL;
14350 }
14351
14352
14353 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14354 PyObject *obj;
14355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14356 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14357 Py_INCREF(obj);
14358 return Py_BuildValue((char *)"");
14359 }
14360 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14361 PyObject *resultobj;
14362 wxJPEGHandler *result;
14363 char *kwnames[] = {
14364 NULL
14365 };
14366
14367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 result = (wxJPEGHandler *)new wxJPEGHandler();
14371
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14376 return resultobj;
14377 fail:
14378 return NULL;
14379 }
14380
14381
14382 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14383 PyObject *obj;
14384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14385 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14386 Py_INCREF(obj);
14387 return Py_BuildValue((char *)"");
14388 }
14389 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14390 PyObject *resultobj;
14391 wxPNMHandler *result;
14392 char *kwnames[] = {
14393 NULL
14394 };
14395
14396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (wxPNMHandler *)new wxPNMHandler();
14400
14401 wxPyEndAllowThreads(__tstate);
14402 if (PyErr_Occurred()) SWIG_fail;
14403 }
14404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14405 return resultobj;
14406 fail:
14407 return NULL;
14408 }
14409
14410
14411 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14412 PyObject *obj;
14413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14414 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14415 Py_INCREF(obj);
14416 return Py_BuildValue((char *)"");
14417 }
14418 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14419 PyObject *resultobj;
14420 wxXPMHandler *result;
14421 char *kwnames[] = {
14422 NULL
14423 };
14424
14425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 result = (wxXPMHandler *)new wxXPMHandler();
14429
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14434 return resultobj;
14435 fail:
14436 return NULL;
14437 }
14438
14439
14440 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14441 PyObject *obj;
14442 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14443 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14444 Py_INCREF(obj);
14445 return Py_BuildValue((char *)"");
14446 }
14447 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14448 PyObject *resultobj;
14449 wxTIFFHandler *result;
14450 char *kwnames[] = {
14451 NULL
14452 };
14453
14454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14455 {
14456 PyThreadState* __tstate = wxPyBeginAllowThreads();
14457 result = (wxTIFFHandler *)new wxTIFFHandler();
14458
14459 wxPyEndAllowThreads(__tstate);
14460 if (PyErr_Occurred()) SWIG_fail;
14461 }
14462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14463 return resultobj;
14464 fail:
14465 return NULL;
14466 }
14467
14468
14469 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14470 PyObject *obj;
14471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14472 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14473 Py_INCREF(obj);
14474 return Py_BuildValue((char *)"");
14475 }
14476 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj;
14478 wxImage *arg1 = 0 ;
14479 wxImage *arg2 = 0 ;
14480 int arg3 = (int) 236 ;
14481 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14482 bool result;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 PyObject * obj2 = 0 ;
14486 PyObject * obj3 = 0 ;
14487 char *kwnames[] = {
14488 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14489 };
14490
14491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14492 {
14493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14494 if (SWIG_arg_fail(1)) SWIG_fail;
14495 if (arg1 == NULL) {
14496 SWIG_null_ref("wxImage");
14497 }
14498 if (SWIG_arg_fail(1)) SWIG_fail;
14499 }
14500 {
14501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14502 if (SWIG_arg_fail(2)) SWIG_fail;
14503 if (arg2 == NULL) {
14504 SWIG_null_ref("wxImage");
14505 }
14506 if (SWIG_arg_fail(2)) SWIG_fail;
14507 }
14508 if (obj2) {
14509 {
14510 arg3 = (int)(SWIG_As_int(obj2));
14511 if (SWIG_arg_fail(3)) SWIG_fail;
14512 }
14513 }
14514 if (obj3) {
14515 {
14516 arg4 = (int)(SWIG_As_int(obj3));
14517 if (SWIG_arg_fail(4)) SWIG_fail;
14518 }
14519 }
14520 {
14521 PyThreadState* __tstate = wxPyBeginAllowThreads();
14522 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14523
14524 wxPyEndAllowThreads(__tstate);
14525 if (PyErr_Occurred()) SWIG_fail;
14526 }
14527 {
14528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14529 }
14530 return resultobj;
14531 fail:
14532 return NULL;
14533 }
14534
14535
14536 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14537 PyObject *obj;
14538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14539 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14540 Py_INCREF(obj);
14541 return Py_BuildValue((char *)"");
14542 }
14543 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14544 PyObject *resultobj;
14545 wxEvtHandler *result;
14546 char *kwnames[] = {
14547 NULL
14548 };
14549
14550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14551 {
14552 PyThreadState* __tstate = wxPyBeginAllowThreads();
14553 result = (wxEvtHandler *)new wxEvtHandler();
14554
14555 wxPyEndAllowThreads(__tstate);
14556 if (PyErr_Occurred()) SWIG_fail;
14557 }
14558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14559 return resultobj;
14560 fail:
14561 return NULL;
14562 }
14563
14564
14565 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14566 PyObject *resultobj;
14567 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14568 wxEvtHandler *result;
14569 PyObject * obj0 = 0 ;
14570 char *kwnames[] = {
14571 (char *) "self", NULL
14572 };
14573
14574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14576 if (SWIG_arg_fail(1)) SWIG_fail;
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14580
14581 wxPyEndAllowThreads(__tstate);
14582 if (PyErr_Occurred()) SWIG_fail;
14583 }
14584 {
14585 resultobj = wxPyMake_wxObject(result, 0);
14586 }
14587 return resultobj;
14588 fail:
14589 return NULL;
14590 }
14591
14592
14593 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14594 PyObject *resultobj;
14595 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14596 wxEvtHandler *result;
14597 PyObject * obj0 = 0 ;
14598 char *kwnames[] = {
14599 (char *) "self", NULL
14600 };
14601
14602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14604 if (SWIG_arg_fail(1)) SWIG_fail;
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14608
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 {
14613 resultobj = wxPyMake_wxObject(result, 0);
14614 }
14615 return resultobj;
14616 fail:
14617 return NULL;
14618 }
14619
14620
14621 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14622 PyObject *resultobj;
14623 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14624 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14625 PyObject * obj0 = 0 ;
14626 PyObject * obj1 = 0 ;
14627 char *kwnames[] = {
14628 (char *) "self",(char *) "handler", NULL
14629 };
14630
14631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(1)) SWIG_fail;
14634 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14635 if (SWIG_arg_fail(2)) SWIG_fail;
14636 {
14637 PyThreadState* __tstate = wxPyBeginAllowThreads();
14638 (arg1)->SetNextHandler(arg2);
14639
14640 wxPyEndAllowThreads(__tstate);
14641 if (PyErr_Occurred()) SWIG_fail;
14642 }
14643 Py_INCREF(Py_None); resultobj = Py_None;
14644 return resultobj;
14645 fail:
14646 return NULL;
14647 }
14648
14649
14650 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14651 PyObject *resultobj;
14652 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14653 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14654 PyObject * obj0 = 0 ;
14655 PyObject * obj1 = 0 ;
14656 char *kwnames[] = {
14657 (char *) "self",(char *) "handler", NULL
14658 };
14659
14660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14662 if (SWIG_arg_fail(1)) SWIG_fail;
14663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14664 if (SWIG_arg_fail(2)) SWIG_fail;
14665 {
14666 PyThreadState* __tstate = wxPyBeginAllowThreads();
14667 (arg1)->SetPreviousHandler(arg2);
14668
14669 wxPyEndAllowThreads(__tstate);
14670 if (PyErr_Occurred()) SWIG_fail;
14671 }
14672 Py_INCREF(Py_None); resultobj = Py_None;
14673 return resultobj;
14674 fail:
14675 return NULL;
14676 }
14677
14678
14679 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14680 PyObject *resultobj;
14681 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14682 bool result;
14683 PyObject * obj0 = 0 ;
14684 char *kwnames[] = {
14685 (char *) "self", NULL
14686 };
14687
14688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14690 if (SWIG_arg_fail(1)) SWIG_fail;
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 result = (bool)(arg1)->GetEvtHandlerEnabled();
14694
14695 wxPyEndAllowThreads(__tstate);
14696 if (PyErr_Occurred()) SWIG_fail;
14697 }
14698 {
14699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14700 }
14701 return resultobj;
14702 fail:
14703 return NULL;
14704 }
14705
14706
14707 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14708 PyObject *resultobj;
14709 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14710 bool arg2 ;
14711 PyObject * obj0 = 0 ;
14712 PyObject * obj1 = 0 ;
14713 char *kwnames[] = {
14714 (char *) "self",(char *) "enabled", NULL
14715 };
14716
14717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14719 if (SWIG_arg_fail(1)) SWIG_fail;
14720 {
14721 arg2 = (bool)(SWIG_As_bool(obj1));
14722 if (SWIG_arg_fail(2)) SWIG_fail;
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 (arg1)->SetEvtHandlerEnabled(arg2);
14727
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 Py_INCREF(Py_None); resultobj = Py_None;
14732 return resultobj;
14733 fail:
14734 return NULL;
14735 }
14736
14737
14738 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14739 PyObject *resultobj;
14740 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14741 wxEvent *arg2 = 0 ;
14742 bool result;
14743 PyObject * obj0 = 0 ;
14744 PyObject * obj1 = 0 ;
14745 char *kwnames[] = {
14746 (char *) "self",(char *) "event", NULL
14747 };
14748
14749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14751 if (SWIG_arg_fail(1)) SWIG_fail;
14752 {
14753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14754 if (SWIG_arg_fail(2)) SWIG_fail;
14755 if (arg2 == NULL) {
14756 SWIG_null_ref("wxEvent");
14757 }
14758 if (SWIG_arg_fail(2)) SWIG_fail;
14759 }
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 result = (bool)(arg1)->ProcessEvent(*arg2);
14763
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 {
14768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14769 }
14770 return resultobj;
14771 fail:
14772 return NULL;
14773 }
14774
14775
14776 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14777 PyObject *resultobj;
14778 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14779 wxEvent *arg2 = 0 ;
14780 PyObject * obj0 = 0 ;
14781 PyObject * obj1 = 0 ;
14782 char *kwnames[] = {
14783 (char *) "self",(char *) "event", NULL
14784 };
14785
14786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14788 if (SWIG_arg_fail(1)) SWIG_fail;
14789 {
14790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14791 if (SWIG_arg_fail(2)) SWIG_fail;
14792 if (arg2 == NULL) {
14793 SWIG_null_ref("wxEvent");
14794 }
14795 if (SWIG_arg_fail(2)) SWIG_fail;
14796 }
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 (arg1)->AddPendingEvent(*arg2);
14800
14801 wxPyEndAllowThreads(__tstate);
14802 if (PyErr_Occurred()) SWIG_fail;
14803 }
14804 Py_INCREF(Py_None); resultobj = Py_None;
14805 return resultobj;
14806 fail:
14807 return NULL;
14808 }
14809
14810
14811 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14812 PyObject *resultobj;
14813 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14814 PyObject * obj0 = 0 ;
14815 char *kwnames[] = {
14816 (char *) "self", NULL
14817 };
14818
14819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14821 if (SWIG_arg_fail(1)) SWIG_fail;
14822 {
14823 PyThreadState* __tstate = wxPyBeginAllowThreads();
14824 (arg1)->ProcessPendingEvents();
14825
14826 wxPyEndAllowThreads(__tstate);
14827 if (PyErr_Occurred()) SWIG_fail;
14828 }
14829 Py_INCREF(Py_None); resultobj = Py_None;
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14837 PyObject *resultobj;
14838 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14839 int arg2 ;
14840 int arg3 ;
14841 int arg4 ;
14842 PyObject *arg5 = (PyObject *) 0 ;
14843 PyObject * obj0 = 0 ;
14844 PyObject * obj1 = 0 ;
14845 PyObject * obj2 = 0 ;
14846 PyObject * obj3 = 0 ;
14847 PyObject * obj4 = 0 ;
14848 char *kwnames[] = {
14849 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14850 };
14851
14852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14854 if (SWIG_arg_fail(1)) SWIG_fail;
14855 {
14856 arg2 = (int)(SWIG_As_int(obj1));
14857 if (SWIG_arg_fail(2)) SWIG_fail;
14858 }
14859 {
14860 arg3 = (int)(SWIG_As_int(obj2));
14861 if (SWIG_arg_fail(3)) SWIG_fail;
14862 }
14863 {
14864 arg4 = (int)(SWIG_As_int(obj3));
14865 if (SWIG_arg_fail(4)) SWIG_fail;
14866 }
14867 arg5 = obj4;
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14871
14872 wxPyEndAllowThreads(__tstate);
14873 if (PyErr_Occurred()) SWIG_fail;
14874 }
14875 Py_INCREF(Py_None); resultobj = Py_None;
14876 return resultobj;
14877 fail:
14878 return NULL;
14879 }
14880
14881
14882 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14883 PyObject *resultobj;
14884 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14885 int arg2 ;
14886 int arg3 = (int) -1 ;
14887 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14888 bool result;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 PyObject * obj2 = 0 ;
14892 PyObject * obj3 = 0 ;
14893 char *kwnames[] = {
14894 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14895 };
14896
14897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14899 if (SWIG_arg_fail(1)) SWIG_fail;
14900 {
14901 arg2 = (int)(SWIG_As_int(obj1));
14902 if (SWIG_arg_fail(2)) SWIG_fail;
14903 }
14904 if (obj2) {
14905 {
14906 arg3 = (int)(SWIG_As_int(obj2));
14907 if (SWIG_arg_fail(3)) SWIG_fail;
14908 }
14909 }
14910 if (obj3) {
14911 {
14912 arg4 = (wxEventType)(SWIG_As_int(obj3));
14913 if (SWIG_arg_fail(4)) SWIG_fail;
14914 }
14915 }
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14919
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 {
14924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14925 }
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj;
14934 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14935 PyObject *arg2 = (PyObject *) 0 ;
14936 bool arg3 = (bool) true ;
14937 PyObject * obj0 = 0 ;
14938 PyObject * obj1 = 0 ;
14939 PyObject * obj2 = 0 ;
14940 char *kwnames[] = {
14941 (char *) "self",(char *) "_self",(char *) "incref", NULL
14942 };
14943
14944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14946 if (SWIG_arg_fail(1)) SWIG_fail;
14947 arg2 = obj1;
14948 if (obj2) {
14949 {
14950 arg3 = (bool)(SWIG_As_bool(obj2));
14951 if (SWIG_arg_fail(3)) SWIG_fail;
14952 }
14953 }
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14957
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 Py_INCREF(Py_None); resultobj = Py_None;
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14969 PyObject *obj;
14970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14971 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14972 Py_INCREF(obj);
14973 return Py_BuildValue((char *)"");
14974 }
14975 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14976 PyObject *resultobj;
14977 wxEventType result;
14978 char *kwnames[] = {
14979 NULL
14980 };
14981
14982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14983 {
14984 PyThreadState* __tstate = wxPyBeginAllowThreads();
14985 result = (wxEventType)wxNewEventType();
14986
14987 wxPyEndAllowThreads(__tstate);
14988 if (PyErr_Occurred()) SWIG_fail;
14989 }
14990 {
14991 resultobj = SWIG_From_int((int)(result));
14992 }
14993 return resultobj;
14994 fail:
14995 return NULL;
14996 }
14997
14998
14999 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15000 PyObject *resultobj;
15001 wxEvent *arg1 = (wxEvent *) 0 ;
15002 PyObject * obj0 = 0 ;
15003 char *kwnames[] = {
15004 (char *) "self", NULL
15005 };
15006
15007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15009 if (SWIG_arg_fail(1)) SWIG_fail;
15010 {
15011 PyThreadState* __tstate = wxPyBeginAllowThreads();
15012 delete arg1;
15013
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 Py_INCREF(Py_None); resultobj = Py_None;
15018 return resultobj;
15019 fail:
15020 return NULL;
15021 }
15022
15023
15024 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15025 PyObject *resultobj;
15026 wxEvent *arg1 = (wxEvent *) 0 ;
15027 wxEventType arg2 ;
15028 PyObject * obj0 = 0 ;
15029 PyObject * obj1 = 0 ;
15030 char *kwnames[] = {
15031 (char *) "self",(char *) "typ", NULL
15032 };
15033
15034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15036 if (SWIG_arg_fail(1)) SWIG_fail;
15037 {
15038 arg2 = (wxEventType)(SWIG_As_int(obj1));
15039 if (SWIG_arg_fail(2)) SWIG_fail;
15040 }
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 (arg1)->SetEventType(arg2);
15044
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 Py_INCREF(Py_None); resultobj = Py_None;
15049 return resultobj;
15050 fail:
15051 return NULL;
15052 }
15053
15054
15055 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15056 PyObject *resultobj;
15057 wxEvent *arg1 = (wxEvent *) 0 ;
15058 wxEventType result;
15059 PyObject * obj0 = 0 ;
15060 char *kwnames[] = {
15061 (char *) "self", NULL
15062 };
15063
15064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15066 if (SWIG_arg_fail(1)) SWIG_fail;
15067 {
15068 PyThreadState* __tstate = wxPyBeginAllowThreads();
15069 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15070
15071 wxPyEndAllowThreads(__tstate);
15072 if (PyErr_Occurred()) SWIG_fail;
15073 }
15074 {
15075 resultobj = SWIG_From_int((int)(result));
15076 }
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15084 PyObject *resultobj;
15085 wxEvent *arg1 = (wxEvent *) 0 ;
15086 wxObject *result;
15087 PyObject * obj0 = 0 ;
15088 char *kwnames[] = {
15089 (char *) "self", NULL
15090 };
15091
15092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15094 if (SWIG_arg_fail(1)) SWIG_fail;
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15098
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 {
15103 resultobj = wxPyMake_wxObject(result, 0);
15104 }
15105 return resultobj;
15106 fail:
15107 return NULL;
15108 }
15109
15110
15111 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15112 PyObject *resultobj;
15113 wxEvent *arg1 = (wxEvent *) 0 ;
15114 wxObject *arg2 = (wxObject *) 0 ;
15115 PyObject * obj0 = 0 ;
15116 PyObject * obj1 = 0 ;
15117 char *kwnames[] = {
15118 (char *) "self",(char *) "obj", NULL
15119 };
15120
15121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15123 if (SWIG_arg_fail(1)) SWIG_fail;
15124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15125 if (SWIG_arg_fail(2)) SWIG_fail;
15126 {
15127 PyThreadState* __tstate = wxPyBeginAllowThreads();
15128 (arg1)->SetEventObject(arg2);
15129
15130 wxPyEndAllowThreads(__tstate);
15131 if (PyErr_Occurred()) SWIG_fail;
15132 }
15133 Py_INCREF(Py_None); resultobj = Py_None;
15134 return resultobj;
15135 fail:
15136 return NULL;
15137 }
15138
15139
15140 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15141 PyObject *resultobj;
15142 wxEvent *arg1 = (wxEvent *) 0 ;
15143 long result;
15144 PyObject * obj0 = 0 ;
15145 char *kwnames[] = {
15146 (char *) "self", NULL
15147 };
15148
15149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15151 if (SWIG_arg_fail(1)) SWIG_fail;
15152 {
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15155
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 {
15160 resultobj = SWIG_From_long((long)(result));
15161 }
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15169 PyObject *resultobj;
15170 wxEvent *arg1 = (wxEvent *) 0 ;
15171 long arg2 = (long) 0 ;
15172 PyObject * obj0 = 0 ;
15173 PyObject * obj1 = 0 ;
15174 char *kwnames[] = {
15175 (char *) "self",(char *) "ts", NULL
15176 };
15177
15178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15180 if (SWIG_arg_fail(1)) SWIG_fail;
15181 if (obj1) {
15182 {
15183 arg2 = (long)(SWIG_As_long(obj1));
15184 if (SWIG_arg_fail(2)) SWIG_fail;
15185 }
15186 }
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 (arg1)->SetTimestamp(arg2);
15190
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 Py_INCREF(Py_None); resultobj = Py_None;
15195 return resultobj;
15196 fail:
15197 return NULL;
15198 }
15199
15200
15201 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15202 PyObject *resultobj;
15203 wxEvent *arg1 = (wxEvent *) 0 ;
15204 int result;
15205 PyObject * obj0 = 0 ;
15206 char *kwnames[] = {
15207 (char *) "self", NULL
15208 };
15209
15210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15212 if (SWIG_arg_fail(1)) SWIG_fail;
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 result = (int)((wxEvent const *)arg1)->GetId();
15216
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 {
15221 resultobj = SWIG_From_int((int)(result));
15222 }
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj;
15231 wxEvent *arg1 = (wxEvent *) 0 ;
15232 int arg2 ;
15233 PyObject * obj0 = 0 ;
15234 PyObject * obj1 = 0 ;
15235 char *kwnames[] = {
15236 (char *) "self",(char *) "Id", NULL
15237 };
15238
15239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15241 if (SWIG_arg_fail(1)) SWIG_fail;
15242 {
15243 arg2 = (int)(SWIG_As_int(obj1));
15244 if (SWIG_arg_fail(2)) SWIG_fail;
15245 }
15246 {
15247 PyThreadState* __tstate = wxPyBeginAllowThreads();
15248 (arg1)->SetId(arg2);
15249
15250 wxPyEndAllowThreads(__tstate);
15251 if (PyErr_Occurred()) SWIG_fail;
15252 }
15253 Py_INCREF(Py_None); resultobj = Py_None;
15254 return resultobj;
15255 fail:
15256 return NULL;
15257 }
15258
15259
15260 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15261 PyObject *resultobj;
15262 wxEvent *arg1 = (wxEvent *) 0 ;
15263 bool result;
15264 PyObject * obj0 = 0 ;
15265 char *kwnames[] = {
15266 (char *) "self", NULL
15267 };
15268
15269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15271 if (SWIG_arg_fail(1)) SWIG_fail;
15272 {
15273 PyThreadState* __tstate = wxPyBeginAllowThreads();
15274 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15275
15276 wxPyEndAllowThreads(__tstate);
15277 if (PyErr_Occurred()) SWIG_fail;
15278 }
15279 {
15280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15281 }
15282 return resultobj;
15283 fail:
15284 return NULL;
15285 }
15286
15287
15288 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15289 PyObject *resultobj;
15290 wxEvent *arg1 = (wxEvent *) 0 ;
15291 bool arg2 = (bool) true ;
15292 PyObject * obj0 = 0 ;
15293 PyObject * obj1 = 0 ;
15294 char *kwnames[] = {
15295 (char *) "self",(char *) "skip", NULL
15296 };
15297
15298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15300 if (SWIG_arg_fail(1)) SWIG_fail;
15301 if (obj1) {
15302 {
15303 arg2 = (bool)(SWIG_As_bool(obj1));
15304 if (SWIG_arg_fail(2)) SWIG_fail;
15305 }
15306 }
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 (arg1)->Skip(arg2);
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 Py_INCREF(Py_None); resultobj = Py_None;
15315 return resultobj;
15316 fail:
15317 return NULL;
15318 }
15319
15320
15321 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15322 PyObject *resultobj;
15323 wxEvent *arg1 = (wxEvent *) 0 ;
15324 bool result;
15325 PyObject * obj0 = 0 ;
15326 char *kwnames[] = {
15327 (char *) "self", NULL
15328 };
15329
15330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15332 if (SWIG_arg_fail(1)) SWIG_fail;
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15336
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 {
15341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15342 }
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15350 PyObject *resultobj;
15351 wxEvent *arg1 = (wxEvent *) 0 ;
15352 bool result;
15353 PyObject * obj0 = 0 ;
15354 char *kwnames[] = {
15355 (char *) "self", NULL
15356 };
15357
15358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15360 if (SWIG_arg_fail(1)) SWIG_fail;
15361 {
15362 PyThreadState* __tstate = wxPyBeginAllowThreads();
15363 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15364
15365 wxPyEndAllowThreads(__tstate);
15366 if (PyErr_Occurred()) SWIG_fail;
15367 }
15368 {
15369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15370 }
15371 return resultobj;
15372 fail:
15373 return NULL;
15374 }
15375
15376
15377 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15378 PyObject *resultobj;
15379 wxEvent *arg1 = (wxEvent *) 0 ;
15380 int result;
15381 PyObject * obj0 = 0 ;
15382 char *kwnames[] = {
15383 (char *) "self", NULL
15384 };
15385
15386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15388 if (SWIG_arg_fail(1)) SWIG_fail;
15389 {
15390 PyThreadState* __tstate = wxPyBeginAllowThreads();
15391 result = (int)(arg1)->StopPropagation();
15392
15393 wxPyEndAllowThreads(__tstate);
15394 if (PyErr_Occurred()) SWIG_fail;
15395 }
15396 {
15397 resultobj = SWIG_From_int((int)(result));
15398 }
15399 return resultobj;
15400 fail:
15401 return NULL;
15402 }
15403
15404
15405 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15406 PyObject *resultobj;
15407 wxEvent *arg1 = (wxEvent *) 0 ;
15408 int arg2 ;
15409 PyObject * obj0 = 0 ;
15410 PyObject * obj1 = 0 ;
15411 char *kwnames[] = {
15412 (char *) "self",(char *) "propagationLevel", NULL
15413 };
15414
15415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15417 if (SWIG_arg_fail(1)) SWIG_fail;
15418 {
15419 arg2 = (int)(SWIG_As_int(obj1));
15420 if (SWIG_arg_fail(2)) SWIG_fail;
15421 }
15422 {
15423 PyThreadState* __tstate = wxPyBeginAllowThreads();
15424 (arg1)->ResumePropagation(arg2);
15425
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 Py_INCREF(Py_None); resultobj = Py_None;
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15437 PyObject *resultobj;
15438 wxEvent *arg1 = (wxEvent *) 0 ;
15439 wxEvent *result;
15440 PyObject * obj0 = 0 ;
15441 char *kwnames[] = {
15442 (char *) "self", NULL
15443 };
15444
15445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15447 if (SWIG_arg_fail(1)) SWIG_fail;
15448 {
15449 PyThreadState* __tstate = wxPyBeginAllowThreads();
15450 result = (wxEvent *)(arg1)->Clone();
15451
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15456 return resultobj;
15457 fail:
15458 return NULL;
15459 }
15460
15461
15462 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15463 PyObject *obj;
15464 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15465 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15466 Py_INCREF(obj);
15467 return Py_BuildValue((char *)"");
15468 }
15469 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15470 PyObject *resultobj;
15471 wxEvent *arg1 = 0 ;
15472 wxPropagationDisabler *result;
15473 PyObject * obj0 = 0 ;
15474 char *kwnames[] = {
15475 (char *) "event", NULL
15476 };
15477
15478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15479 {
15480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15481 if (SWIG_arg_fail(1)) SWIG_fail;
15482 if (arg1 == NULL) {
15483 SWIG_null_ref("wxEvent");
15484 }
15485 if (SWIG_arg_fail(1)) SWIG_fail;
15486 }
15487 {
15488 PyThreadState* __tstate = wxPyBeginAllowThreads();
15489 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15490
15491 wxPyEndAllowThreads(__tstate);
15492 if (PyErr_Occurred()) SWIG_fail;
15493 }
15494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15495 return resultobj;
15496 fail:
15497 return NULL;
15498 }
15499
15500
15501 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15502 PyObject *resultobj;
15503 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15504 PyObject * obj0 = 0 ;
15505 char *kwnames[] = {
15506 (char *) "self", NULL
15507 };
15508
15509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15511 if (SWIG_arg_fail(1)) SWIG_fail;
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 delete arg1;
15515
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 Py_INCREF(Py_None); resultobj = Py_None;
15520 return resultobj;
15521 fail:
15522 return NULL;
15523 }
15524
15525
15526 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15527 PyObject *obj;
15528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15529 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15530 Py_INCREF(obj);
15531 return Py_BuildValue((char *)"");
15532 }
15533 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15534 PyObject *resultobj;
15535 wxEvent *arg1 = 0 ;
15536 wxPropagateOnce *result;
15537 PyObject * obj0 = 0 ;
15538 char *kwnames[] = {
15539 (char *) "event", NULL
15540 };
15541
15542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15543 {
15544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15545 if (SWIG_arg_fail(1)) SWIG_fail;
15546 if (arg1 == NULL) {
15547 SWIG_null_ref("wxEvent");
15548 }
15549 if (SWIG_arg_fail(1)) SWIG_fail;
15550 }
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15554
15555 wxPyEndAllowThreads(__tstate);
15556 if (PyErr_Occurred()) SWIG_fail;
15557 }
15558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15559 return resultobj;
15560 fail:
15561 return NULL;
15562 }
15563
15564
15565 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15566 PyObject *resultobj;
15567 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15568 PyObject * obj0 = 0 ;
15569 char *kwnames[] = {
15570 (char *) "self", NULL
15571 };
15572
15573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15575 if (SWIG_arg_fail(1)) SWIG_fail;
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 delete arg1;
15579
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 Py_INCREF(Py_None); resultobj = Py_None;
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15591 PyObject *obj;
15592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15593 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15594 Py_INCREF(obj);
15595 return Py_BuildValue((char *)"");
15596 }
15597 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15598 PyObject *resultobj;
15599 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15600 int arg2 = (int) 0 ;
15601 wxCommandEvent *result;
15602 PyObject * obj0 = 0 ;
15603 PyObject * obj1 = 0 ;
15604 char *kwnames[] = {
15605 (char *) "commandType",(char *) "winid", NULL
15606 };
15607
15608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15609 if (obj0) {
15610 {
15611 arg1 = (wxEventType)(SWIG_As_int(obj0));
15612 if (SWIG_arg_fail(1)) SWIG_fail;
15613 }
15614 }
15615 if (obj1) {
15616 {
15617 arg2 = (int)(SWIG_As_int(obj1));
15618 if (SWIG_arg_fail(2)) SWIG_fail;
15619 }
15620 }
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15624
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15636 PyObject *resultobj;
15637 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15638 int result;
15639 PyObject * obj0 = 0 ;
15640 char *kwnames[] = {
15641 (char *) "self", NULL
15642 };
15643
15644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15646 if (SWIG_arg_fail(1)) SWIG_fail;
15647 {
15648 PyThreadState* __tstate = wxPyBeginAllowThreads();
15649 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15650
15651 wxPyEndAllowThreads(__tstate);
15652 if (PyErr_Occurred()) SWIG_fail;
15653 }
15654 {
15655 resultobj = SWIG_From_int((int)(result));
15656 }
15657 return resultobj;
15658 fail:
15659 return NULL;
15660 }
15661
15662
15663 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15664 PyObject *resultobj;
15665 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15666 wxString *arg2 = 0 ;
15667 bool temp2 = false ;
15668 PyObject * obj0 = 0 ;
15669 PyObject * obj1 = 0 ;
15670 char *kwnames[] = {
15671 (char *) "self",(char *) "s", NULL
15672 };
15673
15674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15676 if (SWIG_arg_fail(1)) SWIG_fail;
15677 {
15678 arg2 = wxString_in_helper(obj1);
15679 if (arg2 == NULL) SWIG_fail;
15680 temp2 = true;
15681 }
15682 {
15683 PyThreadState* __tstate = wxPyBeginAllowThreads();
15684 (arg1)->SetString((wxString const &)*arg2);
15685
15686 wxPyEndAllowThreads(__tstate);
15687 if (PyErr_Occurred()) SWIG_fail;
15688 }
15689 Py_INCREF(Py_None); resultobj = Py_None;
15690 {
15691 if (temp2)
15692 delete arg2;
15693 }
15694 return resultobj;
15695 fail:
15696 {
15697 if (temp2)
15698 delete arg2;
15699 }
15700 return NULL;
15701 }
15702
15703
15704 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15705 PyObject *resultobj;
15706 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15707 wxString result;
15708 PyObject * obj0 = 0 ;
15709 char *kwnames[] = {
15710 (char *) "self", NULL
15711 };
15712
15713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15715 if (SWIG_arg_fail(1)) SWIG_fail;
15716 {
15717 PyThreadState* __tstate = wxPyBeginAllowThreads();
15718 result = ((wxCommandEvent const *)arg1)->GetString();
15719
15720 wxPyEndAllowThreads(__tstate);
15721 if (PyErr_Occurred()) SWIG_fail;
15722 }
15723 {
15724 #if wxUSE_UNICODE
15725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15726 #else
15727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15728 #endif
15729 }
15730 return resultobj;
15731 fail:
15732 return NULL;
15733 }
15734
15735
15736 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15737 PyObject *resultobj;
15738 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15739 bool result;
15740 PyObject * obj0 = 0 ;
15741 char *kwnames[] = {
15742 (char *) "self", NULL
15743 };
15744
15745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15747 if (SWIG_arg_fail(1)) SWIG_fail;
15748 {
15749 PyThreadState* __tstate = wxPyBeginAllowThreads();
15750 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15751
15752 wxPyEndAllowThreads(__tstate);
15753 if (PyErr_Occurred()) SWIG_fail;
15754 }
15755 {
15756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15757 }
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15765 PyObject *resultobj;
15766 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15767 bool result;
15768 PyObject * obj0 = 0 ;
15769 char *kwnames[] = {
15770 (char *) "self", NULL
15771 };
15772
15773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15775 if (SWIG_arg_fail(1)) SWIG_fail;
15776 {
15777 PyThreadState* __tstate = wxPyBeginAllowThreads();
15778 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15779
15780 wxPyEndAllowThreads(__tstate);
15781 if (PyErr_Occurred()) SWIG_fail;
15782 }
15783 {
15784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15785 }
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15793 PyObject *resultobj;
15794 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15795 long arg2 ;
15796 PyObject * obj0 = 0 ;
15797 PyObject * obj1 = 0 ;
15798 char *kwnames[] = {
15799 (char *) "self",(char *) "extraLong", NULL
15800 };
15801
15802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15804 if (SWIG_arg_fail(1)) SWIG_fail;
15805 {
15806 arg2 = (long)(SWIG_As_long(obj1));
15807 if (SWIG_arg_fail(2)) SWIG_fail;
15808 }
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 (arg1)->SetExtraLong(arg2);
15812
15813 wxPyEndAllowThreads(__tstate);
15814 if (PyErr_Occurred()) SWIG_fail;
15815 }
15816 Py_INCREF(Py_None); resultobj = Py_None;
15817 return resultobj;
15818 fail:
15819 return NULL;
15820 }
15821
15822
15823 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15824 PyObject *resultobj;
15825 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15826 long result;
15827 PyObject * obj0 = 0 ;
15828 char *kwnames[] = {
15829 (char *) "self", NULL
15830 };
15831
15832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15834 if (SWIG_arg_fail(1)) SWIG_fail;
15835 {
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15838
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 {
15843 resultobj = SWIG_From_long((long)(result));
15844 }
15845 return resultobj;
15846 fail:
15847 return NULL;
15848 }
15849
15850
15851 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15852 PyObject *resultobj;
15853 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15854 int arg2 ;
15855 PyObject * obj0 = 0 ;
15856 PyObject * obj1 = 0 ;
15857 char *kwnames[] = {
15858 (char *) "self",(char *) "i", NULL
15859 };
15860
15861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15863 if (SWIG_arg_fail(1)) SWIG_fail;
15864 {
15865 arg2 = (int)(SWIG_As_int(obj1));
15866 if (SWIG_arg_fail(2)) SWIG_fail;
15867 }
15868 {
15869 PyThreadState* __tstate = wxPyBeginAllowThreads();
15870 (arg1)->SetInt(arg2);
15871
15872 wxPyEndAllowThreads(__tstate);
15873 if (PyErr_Occurred()) SWIG_fail;
15874 }
15875 Py_INCREF(Py_None); resultobj = Py_None;
15876 return resultobj;
15877 fail:
15878 return NULL;
15879 }
15880
15881
15882 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15883 PyObject *resultobj;
15884 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15885 long result;
15886 PyObject * obj0 = 0 ;
15887 char *kwnames[] = {
15888 (char *) "self", NULL
15889 };
15890
15891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15893 if (SWIG_arg_fail(1)) SWIG_fail;
15894 {
15895 PyThreadState* __tstate = wxPyBeginAllowThreads();
15896 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15897
15898 wxPyEndAllowThreads(__tstate);
15899 if (PyErr_Occurred()) SWIG_fail;
15900 }
15901 {
15902 resultobj = SWIG_From_long((long)(result));
15903 }
15904 return resultobj;
15905 fail:
15906 return NULL;
15907 }
15908
15909
15910 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15911 PyObject *resultobj;
15912 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15913 wxEvent *result;
15914 PyObject * obj0 = 0 ;
15915 char *kwnames[] = {
15916 (char *) "self", NULL
15917 };
15918
15919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15921 if (SWIG_arg_fail(1)) SWIG_fail;
15922 {
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15925
15926 wxPyEndAllowThreads(__tstate);
15927 if (PyErr_Occurred()) SWIG_fail;
15928 }
15929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15930 return resultobj;
15931 fail:
15932 return NULL;
15933 }
15934
15935
15936 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15937 PyObject *obj;
15938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15939 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15940 Py_INCREF(obj);
15941 return Py_BuildValue((char *)"");
15942 }
15943 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15944 PyObject *resultobj;
15945 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15946 int arg2 = (int) 0 ;
15947 wxNotifyEvent *result;
15948 PyObject * obj0 = 0 ;
15949 PyObject * obj1 = 0 ;
15950 char *kwnames[] = {
15951 (char *) "commandType",(char *) "winid", NULL
15952 };
15953
15954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15955 if (obj0) {
15956 {
15957 arg1 = (wxEventType)(SWIG_As_int(obj0));
15958 if (SWIG_arg_fail(1)) SWIG_fail;
15959 }
15960 }
15961 if (obj1) {
15962 {
15963 arg2 = (int)(SWIG_As_int(obj1));
15964 if (SWIG_arg_fail(2)) SWIG_fail;
15965 }
15966 }
15967 {
15968 PyThreadState* __tstate = wxPyBeginAllowThreads();
15969 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15970
15971 wxPyEndAllowThreads(__tstate);
15972 if (PyErr_Occurred()) SWIG_fail;
15973 }
15974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15975 return resultobj;
15976 fail:
15977 return NULL;
15978 }
15979
15980
15981 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15982 PyObject *resultobj;
15983 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15984 PyObject * obj0 = 0 ;
15985 char *kwnames[] = {
15986 (char *) "self", NULL
15987 };
15988
15989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15991 if (SWIG_arg_fail(1)) SWIG_fail;
15992 {
15993 PyThreadState* __tstate = wxPyBeginAllowThreads();
15994 (arg1)->Veto();
15995
15996 wxPyEndAllowThreads(__tstate);
15997 if (PyErr_Occurred()) SWIG_fail;
15998 }
15999 Py_INCREF(Py_None); resultobj = Py_None;
16000 return resultobj;
16001 fail:
16002 return NULL;
16003 }
16004
16005
16006 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16007 PyObject *resultobj;
16008 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16009 PyObject * obj0 = 0 ;
16010 char *kwnames[] = {
16011 (char *) "self", NULL
16012 };
16013
16014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16016 if (SWIG_arg_fail(1)) SWIG_fail;
16017 {
16018 PyThreadState* __tstate = wxPyBeginAllowThreads();
16019 (arg1)->Allow();
16020
16021 wxPyEndAllowThreads(__tstate);
16022 if (PyErr_Occurred()) SWIG_fail;
16023 }
16024 Py_INCREF(Py_None); resultobj = Py_None;
16025 return resultobj;
16026 fail:
16027 return NULL;
16028 }
16029
16030
16031 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16032 PyObject *resultobj;
16033 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16034 bool result;
16035 PyObject * obj0 = 0 ;
16036 char *kwnames[] = {
16037 (char *) "self", NULL
16038 };
16039
16040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16042 if (SWIG_arg_fail(1)) SWIG_fail;
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (bool)(arg1)->IsAllowed();
16046
16047 wxPyEndAllowThreads(__tstate);
16048 if (PyErr_Occurred()) SWIG_fail;
16049 }
16050 {
16051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16052 }
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16060 PyObject *obj;
16061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16062 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16063 Py_INCREF(obj);
16064 return Py_BuildValue((char *)"");
16065 }
16066 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16067 PyObject *resultobj;
16068 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16069 int arg2 = (int) 0 ;
16070 int arg3 = (int) 0 ;
16071 int arg4 = (int) 0 ;
16072 wxScrollEvent *result;
16073 PyObject * obj0 = 0 ;
16074 PyObject * obj1 = 0 ;
16075 PyObject * obj2 = 0 ;
16076 PyObject * obj3 = 0 ;
16077 char *kwnames[] = {
16078 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16079 };
16080
16081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16082 if (obj0) {
16083 {
16084 arg1 = (wxEventType)(SWIG_As_int(obj0));
16085 if (SWIG_arg_fail(1)) SWIG_fail;
16086 }
16087 }
16088 if (obj1) {
16089 {
16090 arg2 = (int)(SWIG_As_int(obj1));
16091 if (SWIG_arg_fail(2)) SWIG_fail;
16092 }
16093 }
16094 if (obj2) {
16095 {
16096 arg3 = (int)(SWIG_As_int(obj2));
16097 if (SWIG_arg_fail(3)) SWIG_fail;
16098 }
16099 }
16100 if (obj3) {
16101 {
16102 arg4 = (int)(SWIG_As_int(obj3));
16103 if (SWIG_arg_fail(4)) SWIG_fail;
16104 }
16105 }
16106 {
16107 PyThreadState* __tstate = wxPyBeginAllowThreads();
16108 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16109
16110 wxPyEndAllowThreads(__tstate);
16111 if (PyErr_Occurred()) SWIG_fail;
16112 }
16113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16114 return resultobj;
16115 fail:
16116 return NULL;
16117 }
16118
16119
16120 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16121 PyObject *resultobj;
16122 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16131 if (SWIG_arg_fail(1)) SWIG_fail;
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
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_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16149 PyObject *resultobj;
16150 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16151 int result;
16152 PyObject * obj0 = 0 ;
16153 char *kwnames[] = {
16154 (char *) "self", NULL
16155 };
16156
16157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16159 if (SWIG_arg_fail(1)) SWIG_fail;
16160 {
16161 PyThreadState* __tstate = wxPyBeginAllowThreads();
16162 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16163
16164 wxPyEndAllowThreads(__tstate);
16165 if (PyErr_Occurred()) SWIG_fail;
16166 }
16167 {
16168 resultobj = SWIG_From_int((int)(result));
16169 }
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16177 PyObject *resultobj;
16178 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16179 int arg2 ;
16180 PyObject * obj0 = 0 ;
16181 PyObject * obj1 = 0 ;
16182 char *kwnames[] = {
16183 (char *) "self",(char *) "orient", NULL
16184 };
16185
16186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16188 if (SWIG_arg_fail(1)) SWIG_fail;
16189 {
16190 arg2 = (int)(SWIG_As_int(obj1));
16191 if (SWIG_arg_fail(2)) SWIG_fail;
16192 }
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 (arg1)->SetOrientation(arg2);
16196
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 Py_INCREF(Py_None); resultobj = Py_None;
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj;
16209 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16210 int arg2 ;
16211 PyObject * obj0 = 0 ;
16212 PyObject * obj1 = 0 ;
16213 char *kwnames[] = {
16214 (char *) "self",(char *) "pos", NULL
16215 };
16216
16217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16219 if (SWIG_arg_fail(1)) SWIG_fail;
16220 {
16221 arg2 = (int)(SWIG_As_int(obj1));
16222 if (SWIG_arg_fail(2)) SWIG_fail;
16223 }
16224 {
16225 PyThreadState* __tstate = wxPyBeginAllowThreads();
16226 (arg1)->SetPosition(arg2);
16227
16228 wxPyEndAllowThreads(__tstate);
16229 if (PyErr_Occurred()) SWIG_fail;
16230 }
16231 Py_INCREF(Py_None); resultobj = Py_None;
16232 return resultobj;
16233 fail:
16234 return NULL;
16235 }
16236
16237
16238 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16239 PyObject *obj;
16240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16241 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16242 Py_INCREF(obj);
16243 return Py_BuildValue((char *)"");
16244 }
16245 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16246 PyObject *resultobj;
16247 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16248 int arg2 = (int) 0 ;
16249 int arg3 = (int) 0 ;
16250 wxScrollWinEvent *result;
16251 PyObject * obj0 = 0 ;
16252 PyObject * obj1 = 0 ;
16253 PyObject * obj2 = 0 ;
16254 char *kwnames[] = {
16255 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16256 };
16257
16258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16259 if (obj0) {
16260 {
16261 arg1 = (wxEventType)(SWIG_As_int(obj0));
16262 if (SWIG_arg_fail(1)) SWIG_fail;
16263 }
16264 }
16265 if (obj1) {
16266 {
16267 arg2 = (int)(SWIG_As_int(obj1));
16268 if (SWIG_arg_fail(2)) SWIG_fail;
16269 }
16270 }
16271 if (obj2) {
16272 {
16273 arg3 = (int)(SWIG_As_int(obj2));
16274 if (SWIG_arg_fail(3)) SWIG_fail;
16275 }
16276 }
16277 {
16278 PyThreadState* __tstate = wxPyBeginAllowThreads();
16279 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16280
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16292 PyObject *resultobj;
16293 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16294 int result;
16295 PyObject * obj0 = 0 ;
16296 char *kwnames[] = {
16297 (char *) "self", NULL
16298 };
16299
16300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16302 if (SWIG_arg_fail(1)) SWIG_fail;
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16306
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 {
16311 resultobj = SWIG_From_int((int)(result));
16312 }
16313 return resultobj;
16314 fail:
16315 return NULL;
16316 }
16317
16318
16319 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16320 PyObject *resultobj;
16321 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16322 int result;
16323 PyObject * obj0 = 0 ;
16324 char *kwnames[] = {
16325 (char *) "self", NULL
16326 };
16327
16328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16330 if (SWIG_arg_fail(1)) SWIG_fail;
16331 {
16332 PyThreadState* __tstate = wxPyBeginAllowThreads();
16333 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16334
16335 wxPyEndAllowThreads(__tstate);
16336 if (PyErr_Occurred()) SWIG_fail;
16337 }
16338 {
16339 resultobj = SWIG_From_int((int)(result));
16340 }
16341 return resultobj;
16342 fail:
16343 return NULL;
16344 }
16345
16346
16347 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16348 PyObject *resultobj;
16349 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16350 int arg2 ;
16351 PyObject * obj0 = 0 ;
16352 PyObject * obj1 = 0 ;
16353 char *kwnames[] = {
16354 (char *) "self",(char *) "orient", NULL
16355 };
16356
16357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16359 if (SWIG_arg_fail(1)) SWIG_fail;
16360 {
16361 arg2 = (int)(SWIG_As_int(obj1));
16362 if (SWIG_arg_fail(2)) SWIG_fail;
16363 }
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 (arg1)->SetOrientation(arg2);
16367
16368 wxPyEndAllowThreads(__tstate);
16369 if (PyErr_Occurred()) SWIG_fail;
16370 }
16371 Py_INCREF(Py_None); resultobj = Py_None;
16372 return resultobj;
16373 fail:
16374 return NULL;
16375 }
16376
16377
16378 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16379 PyObject *resultobj;
16380 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16381 int arg2 ;
16382 PyObject * obj0 = 0 ;
16383 PyObject * obj1 = 0 ;
16384 char *kwnames[] = {
16385 (char *) "self",(char *) "pos", NULL
16386 };
16387
16388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16390 if (SWIG_arg_fail(1)) SWIG_fail;
16391 {
16392 arg2 = (int)(SWIG_As_int(obj1));
16393 if (SWIG_arg_fail(2)) SWIG_fail;
16394 }
16395 {
16396 PyThreadState* __tstate = wxPyBeginAllowThreads();
16397 (arg1)->SetPosition(arg2);
16398
16399 wxPyEndAllowThreads(__tstate);
16400 if (PyErr_Occurred()) SWIG_fail;
16401 }
16402 Py_INCREF(Py_None); resultobj = Py_None;
16403 return resultobj;
16404 fail:
16405 return NULL;
16406 }
16407
16408
16409 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16410 PyObject *obj;
16411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16412 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16413 Py_INCREF(obj);
16414 return Py_BuildValue((char *)"");
16415 }
16416 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16417 PyObject *resultobj;
16418 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16419 wxMouseEvent *result;
16420 PyObject * obj0 = 0 ;
16421 char *kwnames[] = {
16422 (char *) "mouseType", NULL
16423 };
16424
16425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16426 if (obj0) {
16427 {
16428 arg1 = (wxEventType)(SWIG_As_int(obj0));
16429 if (SWIG_arg_fail(1)) SWIG_fail;
16430 }
16431 }
16432 {
16433 PyThreadState* __tstate = wxPyBeginAllowThreads();
16434 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16435
16436 wxPyEndAllowThreads(__tstate);
16437 if (PyErr_Occurred()) SWIG_fail;
16438 }
16439 {
16440 resultobj = wxPyMake_wxObject(result, 1);
16441 }
16442 return resultobj;
16443 fail:
16444 return NULL;
16445 }
16446
16447
16448 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16449 PyObject *resultobj;
16450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16451 bool result;
16452 PyObject * obj0 = 0 ;
16453 char *kwnames[] = {
16454 (char *) "self", NULL
16455 };
16456
16457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16459 if (SWIG_arg_fail(1)) SWIG_fail;
16460 {
16461 PyThreadState* __tstate = wxPyBeginAllowThreads();
16462 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16463
16464 wxPyEndAllowThreads(__tstate);
16465 if (PyErr_Occurred()) SWIG_fail;
16466 }
16467 {
16468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16469 }
16470 return resultobj;
16471 fail:
16472 return NULL;
16473 }
16474
16475
16476 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16477 PyObject *resultobj;
16478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16479 int arg2 = (int) wxMOUSE_BTN_ANY ;
16480 bool result;
16481 PyObject * obj0 = 0 ;
16482 PyObject * obj1 = 0 ;
16483 char *kwnames[] = {
16484 (char *) "self",(char *) "but", NULL
16485 };
16486
16487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16489 if (SWIG_arg_fail(1)) SWIG_fail;
16490 if (obj1) {
16491 {
16492 arg2 = (int)(SWIG_As_int(obj1));
16493 if (SWIG_arg_fail(2)) SWIG_fail;
16494 }
16495 }
16496 {
16497 PyThreadState* __tstate = wxPyBeginAllowThreads();
16498 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
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_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16513 PyObject *resultobj;
16514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16515 int arg2 = (int) wxMOUSE_BTN_ANY ;
16516 bool result;
16517 PyObject * obj0 = 0 ;
16518 PyObject * obj1 = 0 ;
16519 char *kwnames[] = {
16520 (char *) "self",(char *) "but", NULL
16521 };
16522
16523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16525 if (SWIG_arg_fail(1)) SWIG_fail;
16526 if (obj1) {
16527 {
16528 arg2 = (int)(SWIG_As_int(obj1));
16529 if (SWIG_arg_fail(2)) SWIG_fail;
16530 }
16531 }
16532 {
16533 PyThreadState* __tstate = wxPyBeginAllowThreads();
16534 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16535
16536 wxPyEndAllowThreads(__tstate);
16537 if (PyErr_Occurred()) SWIG_fail;
16538 }
16539 {
16540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16541 }
16542 return resultobj;
16543 fail:
16544 return NULL;
16545 }
16546
16547
16548 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16549 PyObject *resultobj;
16550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16551 int arg2 = (int) wxMOUSE_BTN_ANY ;
16552 bool result;
16553 PyObject * obj0 = 0 ;
16554 PyObject * obj1 = 0 ;
16555 char *kwnames[] = {
16556 (char *) "self",(char *) "but", NULL
16557 };
16558
16559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16561 if (SWIG_arg_fail(1)) SWIG_fail;
16562 if (obj1) {
16563 {
16564 arg2 = (int)(SWIG_As_int(obj1));
16565 if (SWIG_arg_fail(2)) SWIG_fail;
16566 }
16567 }
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16571
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 {
16576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16577 }
16578 return resultobj;
16579 fail:
16580 return NULL;
16581 }
16582
16583
16584 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16585 PyObject *resultobj;
16586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16587 int arg2 ;
16588 bool result;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 char *kwnames[] = {
16592 (char *) "self",(char *) "button", NULL
16593 };
16594
16595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16597 if (SWIG_arg_fail(1)) SWIG_fail;
16598 {
16599 arg2 = (int)(SWIG_As_int(obj1));
16600 if (SWIG_arg_fail(2)) SWIG_fail;
16601 }
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16605
16606 wxPyEndAllowThreads(__tstate);
16607 if (PyErr_Occurred()) SWIG_fail;
16608 }
16609 {
16610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16611 }
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16619 PyObject *resultobj;
16620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16621 int arg2 ;
16622 bool result;
16623 PyObject * obj0 = 0 ;
16624 PyObject * obj1 = 0 ;
16625 char *kwnames[] = {
16626 (char *) "self",(char *) "but", NULL
16627 };
16628
16629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16631 if (SWIG_arg_fail(1)) SWIG_fail;
16632 {
16633 arg2 = (int)(SWIG_As_int(obj1));
16634 if (SWIG_arg_fail(2)) SWIG_fail;
16635 }
16636 {
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
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_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj;
16654 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16655 int result;
16656 PyObject * obj0 = 0 ;
16657 char *kwnames[] = {
16658 (char *) "self", NULL
16659 };
16660
16661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",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 = (int)((wxMouseEvent const *)arg1)->GetButton();
16667
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 {
16672 resultobj = SWIG_From_int((int)(result));
16673 }
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 static PyObject *_wrap_MouseEvent_ControlDown(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_ControlDown",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)->ControlDown();
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_MetaDown(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_MetaDown",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)->MetaDown();
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_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16737 PyObject *resultobj;
16738 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16739 bool result;
16740 PyObject * obj0 = 0 ;
16741 char *kwnames[] = {
16742 (char *) "self", NULL
16743 };
16744
16745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",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 = (bool)((wxMouseEvent const *)arg1)->AltDown();
16751
16752 wxPyEndAllowThreads(__tstate);
16753 if (PyErr_Occurred()) SWIG_fail;
16754 }
16755 {
16756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16757 }
16758 return resultobj;
16759 fail:
16760 return NULL;
16761 }
16762
16763
16764 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16765 PyObject *resultobj;
16766 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16767 bool result;
16768 PyObject * obj0 = 0 ;
16769 char *kwnames[] = {
16770 (char *) "self", NULL
16771 };
16772
16773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16775 if (SWIG_arg_fail(1)) SWIG_fail;
16776 {
16777 PyThreadState* __tstate = wxPyBeginAllowThreads();
16778 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16779
16780 wxPyEndAllowThreads(__tstate);
16781 if (PyErr_Occurred()) SWIG_fail;
16782 }
16783 {
16784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16785 }
16786 return resultobj;
16787 fail:
16788 return NULL;
16789 }
16790
16791
16792 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16793 PyObject *resultobj;
16794 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16795 bool result;
16796 PyObject * obj0 = 0 ;
16797 char *kwnames[] = {
16798 (char *) "self", NULL
16799 };
16800
16801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16803 if (SWIG_arg_fail(1)) SWIG_fail;
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16807
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 {
16812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16813 }
16814 return resultobj;
16815 fail:
16816 return NULL;
16817 }
16818
16819
16820 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16821 PyObject *resultobj;
16822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16823 bool result;
16824 PyObject * obj0 = 0 ;
16825 char *kwnames[] = {
16826 (char *) "self", NULL
16827 };
16828
16829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16831 if (SWIG_arg_fail(1)) SWIG_fail;
16832 {
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16835
16836 wxPyEndAllowThreads(__tstate);
16837 if (PyErr_Occurred()) SWIG_fail;
16838 }
16839 {
16840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16841 }
16842 return resultobj;
16843 fail:
16844 return NULL;
16845 }
16846
16847
16848 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16849 PyObject *resultobj;
16850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16851 bool result;
16852 PyObject * obj0 = 0 ;
16853 char *kwnames[] = {
16854 (char *) "self", NULL
16855 };
16856
16857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16859 if (SWIG_arg_fail(1)) SWIG_fail;
16860 {
16861 PyThreadState* __tstate = wxPyBeginAllowThreads();
16862 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16863
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 {
16868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16869 }
16870 return resultobj;
16871 fail:
16872 return NULL;
16873 }
16874
16875
16876 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16877 PyObject *resultobj;
16878 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16879 bool result;
16880 PyObject * obj0 = 0 ;
16881 char *kwnames[] = {
16882 (char *) "self", NULL
16883 };
16884
16885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16887 if (SWIG_arg_fail(1)) SWIG_fail;
16888 {
16889 PyThreadState* __tstate = wxPyBeginAllowThreads();
16890 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16891
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 {
16896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16897 }
16898 return resultobj;
16899 fail:
16900 return NULL;
16901 }
16902
16903
16904 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16905 PyObject *resultobj;
16906 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16907 bool result;
16908 PyObject * obj0 = 0 ;
16909 char *kwnames[] = {
16910 (char *) "self", NULL
16911 };
16912
16913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16915 if (SWIG_arg_fail(1)) SWIG_fail;
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16919
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 {
16924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16925 }
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj;
16934 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16935 bool result;
16936 PyObject * obj0 = 0 ;
16937 char *kwnames[] = {
16938 (char *) "self", NULL
16939 };
16940
16941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16943 if (SWIG_arg_fail(1)) SWIG_fail;
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16947
16948 wxPyEndAllowThreads(__tstate);
16949 if (PyErr_Occurred()) SWIG_fail;
16950 }
16951 {
16952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16953 }
16954 return resultobj;
16955 fail:
16956 return NULL;
16957 }
16958
16959
16960 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16961 PyObject *resultobj;
16962 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16963 bool result;
16964 PyObject * obj0 = 0 ;
16965 char *kwnames[] = {
16966 (char *) "self", NULL
16967 };
16968
16969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16971 if (SWIG_arg_fail(1)) SWIG_fail;
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16975
16976 wxPyEndAllowThreads(__tstate);
16977 if (PyErr_Occurred()) SWIG_fail;
16978 }
16979 {
16980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16981 }
16982 return resultobj;
16983 fail:
16984 return NULL;
16985 }
16986
16987
16988 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16989 PyObject *resultobj;
16990 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16991 bool result;
16992 PyObject * obj0 = 0 ;
16993 char *kwnames[] = {
16994 (char *) "self", NULL
16995 };
16996
16997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16999 if (SWIG_arg_fail(1)) SWIG_fail;
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17003
17004 wxPyEndAllowThreads(__tstate);
17005 if (PyErr_Occurred()) SWIG_fail;
17006 }
17007 {
17008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17009 }
17010 return resultobj;
17011 fail:
17012 return NULL;
17013 }
17014
17015
17016 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17017 PyObject *resultobj;
17018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17019 bool result;
17020 PyObject * obj0 = 0 ;
17021 char *kwnames[] = {
17022 (char *) "self", NULL
17023 };
17024
17025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17027 if (SWIG_arg_fail(1)) SWIG_fail;
17028 {
17029 PyThreadState* __tstate = wxPyBeginAllowThreads();
17030 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17031
17032 wxPyEndAllowThreads(__tstate);
17033 if (PyErr_Occurred()) SWIG_fail;
17034 }
17035 {
17036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17037 }
17038 return resultobj;
17039 fail:
17040 return NULL;
17041 }
17042
17043
17044 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17045 PyObject *resultobj;
17046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17047 bool result;
17048 PyObject * obj0 = 0 ;
17049 char *kwnames[] = {
17050 (char *) "self", NULL
17051 };
17052
17053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17055 if (SWIG_arg_fail(1)) SWIG_fail;
17056 {
17057 PyThreadState* __tstate = wxPyBeginAllowThreads();
17058 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17059
17060 wxPyEndAllowThreads(__tstate);
17061 if (PyErr_Occurred()) SWIG_fail;
17062 }
17063 {
17064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17065 }
17066 return resultobj;
17067 fail:
17068 return NULL;
17069 }
17070
17071
17072 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17073 PyObject *resultobj;
17074 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17075 bool result;
17076 PyObject * obj0 = 0 ;
17077 char *kwnames[] = {
17078 (char *) "self", NULL
17079 };
17080
17081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17083 if (SWIG_arg_fail(1)) SWIG_fail;
17084 {
17085 PyThreadState* __tstate = wxPyBeginAllowThreads();
17086 result = (bool)(arg1)->LeftIsDown();
17087
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 {
17092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17093 }
17094 return resultobj;
17095 fail:
17096 return NULL;
17097 }
17098
17099
17100 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17101 PyObject *resultobj;
17102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17103 bool result;
17104 PyObject * obj0 = 0 ;
17105 char *kwnames[] = {
17106 (char *) "self", NULL
17107 };
17108
17109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17111 if (SWIG_arg_fail(1)) SWIG_fail;
17112 {
17113 PyThreadState* __tstate = wxPyBeginAllowThreads();
17114 result = (bool)(arg1)->MiddleIsDown();
17115
17116 wxPyEndAllowThreads(__tstate);
17117 if (PyErr_Occurred()) SWIG_fail;
17118 }
17119 {
17120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17121 }
17122 return resultobj;
17123 fail:
17124 return NULL;
17125 }
17126
17127
17128 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17129 PyObject *resultobj;
17130 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17131 bool result;
17132 PyObject * obj0 = 0 ;
17133 char *kwnames[] = {
17134 (char *) "self", NULL
17135 };
17136
17137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17139 if (SWIG_arg_fail(1)) SWIG_fail;
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = (bool)(arg1)->RightIsDown();
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17149 }
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj;
17158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17159 bool result;
17160 PyObject * obj0 = 0 ;
17161 char *kwnames[] = {
17162 (char *) "self", NULL
17163 };
17164
17165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17167 if (SWIG_arg_fail(1)) SWIG_fail;
17168 {
17169 PyThreadState* __tstate = wxPyBeginAllowThreads();
17170 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17171
17172 wxPyEndAllowThreads(__tstate);
17173 if (PyErr_Occurred()) SWIG_fail;
17174 }
17175 {
17176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17177 }
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 static PyObject *_wrap_MouseEvent_Moving(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_Moving",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 {
17197 PyThreadState* __tstate = wxPyBeginAllowThreads();
17198 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17199
17200 wxPyEndAllowThreads(__tstate);
17201 if (PyErr_Occurred()) SWIG_fail;
17202 }
17203 {
17204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17205 }
17206 return resultobj;
17207 fail:
17208 return NULL;
17209 }
17210
17211
17212 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17213 PyObject *resultobj;
17214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17215 bool result;
17216 PyObject * obj0 = 0 ;
17217 char *kwnames[] = {
17218 (char *) "self", NULL
17219 };
17220
17221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17223 if (SWIG_arg_fail(1)) SWIG_fail;
17224 {
17225 PyThreadState* __tstate = wxPyBeginAllowThreads();
17226 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17227
17228 wxPyEndAllowThreads(__tstate);
17229 if (PyErr_Occurred()) SWIG_fail;
17230 }
17231 {
17232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17233 }
17234 return resultobj;
17235 fail:
17236 return NULL;
17237 }
17238
17239
17240 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17241 PyObject *resultobj;
17242 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17243 bool result;
17244 PyObject * obj0 = 0 ;
17245 char *kwnames[] = {
17246 (char *) "self", NULL
17247 };
17248
17249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17251 if (SWIG_arg_fail(1)) SWIG_fail;
17252 {
17253 PyThreadState* __tstate = wxPyBeginAllowThreads();
17254 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17255
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 {
17260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17261 }
17262 return resultobj;
17263 fail:
17264 return NULL;
17265 }
17266
17267
17268 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17269 PyObject *resultobj;
17270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17271 wxPoint result;
17272 PyObject * obj0 = 0 ;
17273 char *kwnames[] = {
17274 (char *) "self", NULL
17275 };
17276
17277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17279 if (SWIG_arg_fail(1)) SWIG_fail;
17280 {
17281 PyThreadState* __tstate = wxPyBeginAllowThreads();
17282 result = (arg1)->GetPosition();
17283
17284 wxPyEndAllowThreads(__tstate);
17285 if (PyErr_Occurred()) SWIG_fail;
17286 }
17287 {
17288 wxPoint * resultptr;
17289 resultptr = new wxPoint((wxPoint &)(result));
17290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17291 }
17292 return resultobj;
17293 fail:
17294 return NULL;
17295 }
17296
17297
17298 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17299 PyObject *resultobj;
17300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17301 long *arg2 = (long *) 0 ;
17302 long *arg3 = (long *) 0 ;
17303 long temp2 ;
17304 int res2 = 0 ;
17305 long temp3 ;
17306 int res3 = 0 ;
17307 PyObject * obj0 = 0 ;
17308 char *kwnames[] = {
17309 (char *) "self", NULL
17310 };
17311
17312 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17313 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17316 if (SWIG_arg_fail(1)) SWIG_fail;
17317 {
17318 PyThreadState* __tstate = wxPyBeginAllowThreads();
17319 (arg1)->GetPosition(arg2,arg3);
17320
17321 wxPyEndAllowThreads(__tstate);
17322 if (PyErr_Occurred()) SWIG_fail;
17323 }
17324 Py_INCREF(Py_None); resultobj = Py_None;
17325 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17326 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17327 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17328 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj;
17337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17338 wxDC *arg2 = 0 ;
17339 wxPoint result;
17340 PyObject * obj0 = 0 ;
17341 PyObject * obj1 = 0 ;
17342 char *kwnames[] = {
17343 (char *) "self",(char *) "dc", NULL
17344 };
17345
17346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17348 if (SWIG_arg_fail(1)) SWIG_fail;
17349 {
17350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17351 if (SWIG_arg_fail(2)) SWIG_fail;
17352 if (arg2 == NULL) {
17353 SWIG_null_ref("wxDC");
17354 }
17355 if (SWIG_arg_fail(2)) SWIG_fail;
17356 }
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17360
17361 wxPyEndAllowThreads(__tstate);
17362 if (PyErr_Occurred()) SWIG_fail;
17363 }
17364 {
17365 wxPoint * resultptr;
17366 resultptr = new wxPoint((wxPoint &)(result));
17367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17368 }
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj;
17377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17378 int result;
17379 PyObject * obj0 = 0 ;
17380 char *kwnames[] = {
17381 (char *) "self", NULL
17382 };
17383
17384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17386 if (SWIG_arg_fail(1)) SWIG_fail;
17387 {
17388 PyThreadState* __tstate = wxPyBeginAllowThreads();
17389 result = (int)((wxMouseEvent const *)arg1)->GetX();
17390
17391 wxPyEndAllowThreads(__tstate);
17392 if (PyErr_Occurred()) SWIG_fail;
17393 }
17394 {
17395 resultobj = SWIG_From_int((int)(result));
17396 }
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj;
17405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17406 int result;
17407 PyObject * obj0 = 0 ;
17408 char *kwnames[] = {
17409 (char *) "self", NULL
17410 };
17411
17412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17414 if (SWIG_arg_fail(1)) SWIG_fail;
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (int)((wxMouseEvent const *)arg1)->GetY();
17418
17419 wxPyEndAllowThreads(__tstate);
17420 if (PyErr_Occurred()) SWIG_fail;
17421 }
17422 {
17423 resultobj = SWIG_From_int((int)(result));
17424 }
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj;
17433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17434 int result;
17435 PyObject * obj0 = 0 ;
17436 char *kwnames[] = {
17437 (char *) "self", NULL
17438 };
17439
17440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17442 if (SWIG_arg_fail(1)) SWIG_fail;
17443 {
17444 PyThreadState* __tstate = wxPyBeginAllowThreads();
17445 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17446
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 {
17451 resultobj = SWIG_From_int((int)(result));
17452 }
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj;
17461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17462 int result;
17463 PyObject * obj0 = 0 ;
17464 char *kwnames[] = {
17465 (char *) "self", NULL
17466 };
17467
17468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17470 if (SWIG_arg_fail(1)) SWIG_fail;
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17474
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 {
17479 resultobj = SWIG_From_int((int)(result));
17480 }
17481 return resultobj;
17482 fail:
17483 return NULL;
17484 }
17485
17486
17487 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17488 PyObject *resultobj;
17489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17490 int result;
17491 PyObject * obj0 = 0 ;
17492 char *kwnames[] = {
17493 (char *) "self", NULL
17494 };
17495
17496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17498 if (SWIG_arg_fail(1)) SWIG_fail;
17499 {
17500 PyThreadState* __tstate = wxPyBeginAllowThreads();
17501 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17502
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 {
17507 resultobj = SWIG_From_int((int)(result));
17508 }
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj;
17517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17518 bool result;
17519 PyObject * obj0 = 0 ;
17520 char *kwnames[] = {
17521 (char *) "self", NULL
17522 };
17523
17524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17526 if (SWIG_arg_fail(1)) SWIG_fail;
17527 {
17528 PyThreadState* __tstate = wxPyBeginAllowThreads();
17529 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17530
17531 wxPyEndAllowThreads(__tstate);
17532 if (PyErr_Occurred()) SWIG_fail;
17533 }
17534 {
17535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17536 }
17537 return resultobj;
17538 fail:
17539 return NULL;
17540 }
17541
17542
17543 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17544 PyObject *resultobj;
17545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17546 int arg2 ;
17547 PyObject * obj0 = 0 ;
17548 PyObject * obj1 = 0 ;
17549 char *kwnames[] = {
17550 (char *) "self",(char *) "m_x", NULL
17551 };
17552
17553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17555 if (SWIG_arg_fail(1)) SWIG_fail;
17556 {
17557 arg2 = (int)(SWIG_As_int(obj1));
17558 if (SWIG_arg_fail(2)) SWIG_fail;
17559 }
17560 if (arg1) (arg1)->m_x = arg2;
17561
17562 Py_INCREF(Py_None); resultobj = Py_None;
17563 return resultobj;
17564 fail:
17565 return NULL;
17566 }
17567
17568
17569 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17570 PyObject *resultobj;
17571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17572 int result;
17573 PyObject * obj0 = 0 ;
17574 char *kwnames[] = {
17575 (char *) "self", NULL
17576 };
17577
17578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17580 if (SWIG_arg_fail(1)) SWIG_fail;
17581 result = (int) ((arg1)->m_x);
17582
17583 {
17584 resultobj = SWIG_From_int((int)(result));
17585 }
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj;
17594 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17595 int arg2 ;
17596 PyObject * obj0 = 0 ;
17597 PyObject * obj1 = 0 ;
17598 char *kwnames[] = {
17599 (char *) "self",(char *) "m_y", NULL
17600 };
17601
17602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17604 if (SWIG_arg_fail(1)) SWIG_fail;
17605 {
17606 arg2 = (int)(SWIG_As_int(obj1));
17607 if (SWIG_arg_fail(2)) SWIG_fail;
17608 }
17609 if (arg1) (arg1)->m_y = arg2;
17610
17611 Py_INCREF(Py_None); resultobj = Py_None;
17612 return resultobj;
17613 fail:
17614 return NULL;
17615 }
17616
17617
17618 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17619 PyObject *resultobj;
17620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17621 int result;
17622 PyObject * obj0 = 0 ;
17623 char *kwnames[] = {
17624 (char *) "self", NULL
17625 };
17626
17627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17629 if (SWIG_arg_fail(1)) SWIG_fail;
17630 result = (int) ((arg1)->m_y);
17631
17632 {
17633 resultobj = SWIG_From_int((int)(result));
17634 }
17635 return resultobj;
17636 fail:
17637 return NULL;
17638 }
17639
17640
17641 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17642 PyObject *resultobj;
17643 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17644 bool arg2 ;
17645 PyObject * obj0 = 0 ;
17646 PyObject * obj1 = 0 ;
17647 char *kwnames[] = {
17648 (char *) "self",(char *) "m_leftDown", NULL
17649 };
17650
17651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17653 if (SWIG_arg_fail(1)) SWIG_fail;
17654 {
17655 arg2 = (bool)(SWIG_As_bool(obj1));
17656 if (SWIG_arg_fail(2)) SWIG_fail;
17657 }
17658 if (arg1) (arg1)->m_leftDown = arg2;
17659
17660 Py_INCREF(Py_None); resultobj = Py_None;
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj;
17669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17670 bool result;
17671 PyObject * obj0 = 0 ;
17672 char *kwnames[] = {
17673 (char *) "self", NULL
17674 };
17675
17676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17678 if (SWIG_arg_fail(1)) SWIG_fail;
17679 result = (bool) ((arg1)->m_leftDown);
17680
17681 {
17682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17683 }
17684 return resultobj;
17685 fail:
17686 return NULL;
17687 }
17688
17689
17690 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17691 PyObject *resultobj;
17692 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17693 bool arg2 ;
17694 PyObject * obj0 = 0 ;
17695 PyObject * obj1 = 0 ;
17696 char *kwnames[] = {
17697 (char *) "self",(char *) "m_middleDown", NULL
17698 };
17699
17700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17702 if (SWIG_arg_fail(1)) SWIG_fail;
17703 {
17704 arg2 = (bool)(SWIG_As_bool(obj1));
17705 if (SWIG_arg_fail(2)) SWIG_fail;
17706 }
17707 if (arg1) (arg1)->m_middleDown = arg2;
17708
17709 Py_INCREF(Py_None); resultobj = Py_None;
17710 return resultobj;
17711 fail:
17712 return NULL;
17713 }
17714
17715
17716 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17717 PyObject *resultobj;
17718 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17719 bool result;
17720 PyObject * obj0 = 0 ;
17721 char *kwnames[] = {
17722 (char *) "self", NULL
17723 };
17724
17725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17727 if (SWIG_arg_fail(1)) SWIG_fail;
17728 result = (bool) ((arg1)->m_middleDown);
17729
17730 {
17731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17732 }
17733 return resultobj;
17734 fail:
17735 return NULL;
17736 }
17737
17738
17739 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17740 PyObject *resultobj;
17741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17742 bool arg2 ;
17743 PyObject * obj0 = 0 ;
17744 PyObject * obj1 = 0 ;
17745 char *kwnames[] = {
17746 (char *) "self",(char *) "m_rightDown", NULL
17747 };
17748
17749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17751 if (SWIG_arg_fail(1)) SWIG_fail;
17752 {
17753 arg2 = (bool)(SWIG_As_bool(obj1));
17754 if (SWIG_arg_fail(2)) SWIG_fail;
17755 }
17756 if (arg1) (arg1)->m_rightDown = arg2;
17757
17758 Py_INCREF(Py_None); resultobj = Py_None;
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj;
17767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17768 bool result;
17769 PyObject * obj0 = 0 ;
17770 char *kwnames[] = {
17771 (char *) "self", NULL
17772 };
17773
17774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17776 if (SWIG_arg_fail(1)) SWIG_fail;
17777 result = (bool) ((arg1)->m_rightDown);
17778
17779 {
17780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17781 }
17782 return resultobj;
17783 fail:
17784 return NULL;
17785 }
17786
17787
17788 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17789 PyObject *resultobj;
17790 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17791 bool arg2 ;
17792 PyObject * obj0 = 0 ;
17793 PyObject * obj1 = 0 ;
17794 char *kwnames[] = {
17795 (char *) "self",(char *) "m_controlDown", NULL
17796 };
17797
17798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17800 if (SWIG_arg_fail(1)) SWIG_fail;
17801 {
17802 arg2 = (bool)(SWIG_As_bool(obj1));
17803 if (SWIG_arg_fail(2)) SWIG_fail;
17804 }
17805 if (arg1) (arg1)->m_controlDown = arg2;
17806
17807 Py_INCREF(Py_None); resultobj = Py_None;
17808 return resultobj;
17809 fail:
17810 return NULL;
17811 }
17812
17813
17814 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17815 PyObject *resultobj;
17816 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17817 bool result;
17818 PyObject * obj0 = 0 ;
17819 char *kwnames[] = {
17820 (char *) "self", NULL
17821 };
17822
17823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17825 if (SWIG_arg_fail(1)) SWIG_fail;
17826 result = (bool) ((arg1)->m_controlDown);
17827
17828 {
17829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17830 }
17831 return resultobj;
17832 fail:
17833 return NULL;
17834 }
17835
17836
17837 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17838 PyObject *resultobj;
17839 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17840 bool arg2 ;
17841 PyObject * obj0 = 0 ;
17842 PyObject * obj1 = 0 ;
17843 char *kwnames[] = {
17844 (char *) "self",(char *) "m_shiftDown", NULL
17845 };
17846
17847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17849 if (SWIG_arg_fail(1)) SWIG_fail;
17850 {
17851 arg2 = (bool)(SWIG_As_bool(obj1));
17852 if (SWIG_arg_fail(2)) SWIG_fail;
17853 }
17854 if (arg1) (arg1)->m_shiftDown = arg2;
17855
17856 Py_INCREF(Py_None); resultobj = Py_None;
17857 return resultobj;
17858 fail:
17859 return NULL;
17860 }
17861
17862
17863 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17864 PyObject *resultobj;
17865 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17866 bool result;
17867 PyObject * obj0 = 0 ;
17868 char *kwnames[] = {
17869 (char *) "self", NULL
17870 };
17871
17872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17874 if (SWIG_arg_fail(1)) SWIG_fail;
17875 result = (bool) ((arg1)->m_shiftDown);
17876
17877 {
17878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17879 }
17880 return resultobj;
17881 fail:
17882 return NULL;
17883 }
17884
17885
17886 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17887 PyObject *resultobj;
17888 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17889 bool arg2 ;
17890 PyObject * obj0 = 0 ;
17891 PyObject * obj1 = 0 ;
17892 char *kwnames[] = {
17893 (char *) "self",(char *) "m_altDown", NULL
17894 };
17895
17896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17898 if (SWIG_arg_fail(1)) SWIG_fail;
17899 {
17900 arg2 = (bool)(SWIG_As_bool(obj1));
17901 if (SWIG_arg_fail(2)) SWIG_fail;
17902 }
17903 if (arg1) (arg1)->m_altDown = arg2;
17904
17905 Py_INCREF(Py_None); resultobj = Py_None;
17906 return resultobj;
17907 fail:
17908 return NULL;
17909 }
17910
17911
17912 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17913 PyObject *resultobj;
17914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17915 bool result;
17916 PyObject * obj0 = 0 ;
17917 char *kwnames[] = {
17918 (char *) "self", NULL
17919 };
17920
17921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17923 if (SWIG_arg_fail(1)) SWIG_fail;
17924 result = (bool) ((arg1)->m_altDown);
17925
17926 {
17927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17928 }
17929 return resultobj;
17930 fail:
17931 return NULL;
17932 }
17933
17934
17935 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17936 PyObject *resultobj;
17937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17938 bool arg2 ;
17939 PyObject * obj0 = 0 ;
17940 PyObject * obj1 = 0 ;
17941 char *kwnames[] = {
17942 (char *) "self",(char *) "m_metaDown", NULL
17943 };
17944
17945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17947 if (SWIG_arg_fail(1)) SWIG_fail;
17948 {
17949 arg2 = (bool)(SWIG_As_bool(obj1));
17950 if (SWIG_arg_fail(2)) SWIG_fail;
17951 }
17952 if (arg1) (arg1)->m_metaDown = arg2;
17953
17954 Py_INCREF(Py_None); resultobj = Py_None;
17955 return resultobj;
17956 fail:
17957 return NULL;
17958 }
17959
17960
17961 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj;
17963 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17964 bool result;
17965 PyObject * obj0 = 0 ;
17966 char *kwnames[] = {
17967 (char *) "self", NULL
17968 };
17969
17970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17972 if (SWIG_arg_fail(1)) SWIG_fail;
17973 result = (bool) ((arg1)->m_metaDown);
17974
17975 {
17976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17977 }
17978 return resultobj;
17979 fail:
17980 return NULL;
17981 }
17982
17983
17984 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17985 PyObject *resultobj;
17986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17987 int arg2 ;
17988 PyObject * obj0 = 0 ;
17989 PyObject * obj1 = 0 ;
17990 char *kwnames[] = {
17991 (char *) "self",(char *) "m_wheelRotation", NULL
17992 };
17993
17994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 {
17998 arg2 = (int)(SWIG_As_int(obj1));
17999 if (SWIG_arg_fail(2)) SWIG_fail;
18000 }
18001 if (arg1) (arg1)->m_wheelRotation = arg2;
18002
18003 Py_INCREF(Py_None); resultobj = Py_None;
18004 return resultobj;
18005 fail:
18006 return NULL;
18007 }
18008
18009
18010 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18011 PyObject *resultobj;
18012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18013 int result;
18014 PyObject * obj0 = 0 ;
18015 char *kwnames[] = {
18016 (char *) "self", NULL
18017 };
18018
18019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18021 if (SWIG_arg_fail(1)) SWIG_fail;
18022 result = (int) ((arg1)->m_wheelRotation);
18023
18024 {
18025 resultobj = SWIG_From_int((int)(result));
18026 }
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj;
18035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18036 int arg2 ;
18037 PyObject * obj0 = 0 ;
18038 PyObject * obj1 = 0 ;
18039 char *kwnames[] = {
18040 (char *) "self",(char *) "m_wheelDelta", NULL
18041 };
18042
18043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18045 if (SWIG_arg_fail(1)) SWIG_fail;
18046 {
18047 arg2 = (int)(SWIG_As_int(obj1));
18048 if (SWIG_arg_fail(2)) SWIG_fail;
18049 }
18050 if (arg1) (arg1)->m_wheelDelta = arg2;
18051
18052 Py_INCREF(Py_None); resultobj = Py_None;
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18060 PyObject *resultobj;
18061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18062 int result;
18063 PyObject * obj0 = 0 ;
18064 char *kwnames[] = {
18065 (char *) "self", NULL
18066 };
18067
18068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18070 if (SWIG_arg_fail(1)) SWIG_fail;
18071 result = (int) ((arg1)->m_wheelDelta);
18072
18073 {
18074 resultobj = SWIG_From_int((int)(result));
18075 }
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18083 PyObject *resultobj;
18084 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18085 int arg2 ;
18086 PyObject * obj0 = 0 ;
18087 PyObject * obj1 = 0 ;
18088 char *kwnames[] = {
18089 (char *) "self",(char *) "m_linesPerAction", NULL
18090 };
18091
18092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18094 if (SWIG_arg_fail(1)) SWIG_fail;
18095 {
18096 arg2 = (int)(SWIG_As_int(obj1));
18097 if (SWIG_arg_fail(2)) SWIG_fail;
18098 }
18099 if (arg1) (arg1)->m_linesPerAction = arg2;
18100
18101 Py_INCREF(Py_None); resultobj = Py_None;
18102 return resultobj;
18103 fail:
18104 return NULL;
18105 }
18106
18107
18108 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18109 PyObject *resultobj;
18110 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18111 int result;
18112 PyObject * obj0 = 0 ;
18113 char *kwnames[] = {
18114 (char *) "self", NULL
18115 };
18116
18117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18119 if (SWIG_arg_fail(1)) SWIG_fail;
18120 result = (int) ((arg1)->m_linesPerAction);
18121
18122 {
18123 resultobj = SWIG_From_int((int)(result));
18124 }
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18132 PyObject *obj;
18133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18134 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18135 Py_INCREF(obj);
18136 return Py_BuildValue((char *)"");
18137 }
18138 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18139 PyObject *resultobj;
18140 int arg1 = (int) 0 ;
18141 int arg2 = (int) 0 ;
18142 wxSetCursorEvent *result;
18143 PyObject * obj0 = 0 ;
18144 PyObject * obj1 = 0 ;
18145 char *kwnames[] = {
18146 (char *) "x",(char *) "y", NULL
18147 };
18148
18149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18150 if (obj0) {
18151 {
18152 arg1 = (int)(SWIG_As_int(obj0));
18153 if (SWIG_arg_fail(1)) SWIG_fail;
18154 }
18155 }
18156 if (obj1) {
18157 {
18158 arg2 = (int)(SWIG_As_int(obj1));
18159 if (SWIG_arg_fail(2)) SWIG_fail;
18160 }
18161 }
18162 {
18163 PyThreadState* __tstate = wxPyBeginAllowThreads();
18164 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18165
18166 wxPyEndAllowThreads(__tstate);
18167 if (PyErr_Occurred()) SWIG_fail;
18168 }
18169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18170 return resultobj;
18171 fail:
18172 return NULL;
18173 }
18174
18175
18176 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18177 PyObject *resultobj;
18178 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18179 int result;
18180 PyObject * obj0 = 0 ;
18181 char *kwnames[] = {
18182 (char *) "self", NULL
18183 };
18184
18185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18187 if (SWIG_arg_fail(1)) SWIG_fail;
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18191
18192 wxPyEndAllowThreads(__tstate);
18193 if (PyErr_Occurred()) SWIG_fail;
18194 }
18195 {
18196 resultobj = SWIG_From_int((int)(result));
18197 }
18198 return resultobj;
18199 fail:
18200 return NULL;
18201 }
18202
18203
18204 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18205 PyObject *resultobj;
18206 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18207 int result;
18208 PyObject * obj0 = 0 ;
18209 char *kwnames[] = {
18210 (char *) "self", NULL
18211 };
18212
18213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18215 if (SWIG_arg_fail(1)) SWIG_fail;
18216 {
18217 PyThreadState* __tstate = wxPyBeginAllowThreads();
18218 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18219
18220 wxPyEndAllowThreads(__tstate);
18221 if (PyErr_Occurred()) SWIG_fail;
18222 }
18223 {
18224 resultobj = SWIG_From_int((int)(result));
18225 }
18226 return resultobj;
18227 fail:
18228 return NULL;
18229 }
18230
18231
18232 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18233 PyObject *resultobj;
18234 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18235 wxCursor *arg2 = 0 ;
18236 PyObject * obj0 = 0 ;
18237 PyObject * obj1 = 0 ;
18238 char *kwnames[] = {
18239 (char *) "self",(char *) "cursor", NULL
18240 };
18241
18242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18244 if (SWIG_arg_fail(1)) SWIG_fail;
18245 {
18246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18247 if (SWIG_arg_fail(2)) SWIG_fail;
18248 if (arg2 == NULL) {
18249 SWIG_null_ref("wxCursor");
18250 }
18251 if (SWIG_arg_fail(2)) SWIG_fail;
18252 }
18253 {
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 (arg1)->SetCursor((wxCursor const &)*arg2);
18256
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 Py_INCREF(Py_None); resultobj = Py_None;
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18268 PyObject *resultobj;
18269 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18270 wxCursor *result;
18271 PyObject * obj0 = 0 ;
18272 char *kwnames[] = {
18273 (char *) "self", NULL
18274 };
18275
18276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18278 if (SWIG_arg_fail(1)) SWIG_fail;
18279 {
18280 PyThreadState* __tstate = wxPyBeginAllowThreads();
18281 {
18282 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18283 result = (wxCursor *) &_result_ref;
18284 }
18285
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 {
18290 wxCursor* resultptr = new wxCursor(*result);
18291 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18292 }
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj;
18301 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18302 bool result;
18303 PyObject * obj0 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 PyThreadState* __tstate = wxPyBeginAllowThreads();
18313 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18314
18315 wxPyEndAllowThreads(__tstate);
18316 if (PyErr_Occurred()) SWIG_fail;
18317 }
18318 {
18319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18320 }
18321 return resultobj;
18322 fail:
18323 return NULL;
18324 }
18325
18326
18327 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18328 PyObject *obj;
18329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18330 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18331 Py_INCREF(obj);
18332 return Py_BuildValue((char *)"");
18333 }
18334 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18335 PyObject *resultobj;
18336 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18337 wxKeyEvent *result;
18338 PyObject * obj0 = 0 ;
18339 char *kwnames[] = {
18340 (char *) "eventType", NULL
18341 };
18342
18343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18344 if (obj0) {
18345 {
18346 arg1 = (wxEventType)(SWIG_As_int(obj0));
18347 if (SWIG_arg_fail(1)) SWIG_fail;
18348 }
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18353
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18358 return resultobj;
18359 fail:
18360 return NULL;
18361 }
18362
18363
18364 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18365 PyObject *resultobj;
18366 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18367 bool result;
18368 PyObject * obj0 = 0 ;
18369 char *kwnames[] = {
18370 (char *) "self", NULL
18371 };
18372
18373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18375 if (SWIG_arg_fail(1)) SWIG_fail;
18376 {
18377 PyThreadState* __tstate = wxPyBeginAllowThreads();
18378 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18379
18380 wxPyEndAllowThreads(__tstate);
18381 if (PyErr_Occurred()) SWIG_fail;
18382 }
18383 {
18384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18385 }
18386 return resultobj;
18387 fail:
18388 return NULL;
18389 }
18390
18391
18392 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18393 PyObject *resultobj;
18394 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18395 bool result;
18396 PyObject * obj0 = 0 ;
18397 char *kwnames[] = {
18398 (char *) "self", NULL
18399 };
18400
18401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18403 if (SWIG_arg_fail(1)) SWIG_fail;
18404 {
18405 PyThreadState* __tstate = wxPyBeginAllowThreads();
18406 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18407
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 {
18412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18413 }
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj;
18422 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18423 bool result;
18424 PyObject * obj0 = 0 ;
18425 char *kwnames[] = {
18426 (char *) "self", NULL
18427 };
18428
18429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18431 if (SWIG_arg_fail(1)) SWIG_fail;
18432 {
18433 PyThreadState* __tstate = wxPyBeginAllowThreads();
18434 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18435
18436 wxPyEndAllowThreads(__tstate);
18437 if (PyErr_Occurred()) SWIG_fail;
18438 }
18439 {
18440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18441 }
18442 return resultobj;
18443 fail:
18444 return NULL;
18445 }
18446
18447
18448 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18449 PyObject *resultobj;
18450 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18451 bool result;
18452 PyObject * obj0 = 0 ;
18453 char *kwnames[] = {
18454 (char *) "self", NULL
18455 };
18456
18457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18459 if (SWIG_arg_fail(1)) SWIG_fail;
18460 {
18461 PyThreadState* __tstate = wxPyBeginAllowThreads();
18462 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18463
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 {
18468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18469 }
18470 return resultobj;
18471 fail:
18472 return NULL;
18473 }
18474
18475
18476 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18477 PyObject *resultobj;
18478 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18479 bool result;
18480 PyObject * obj0 = 0 ;
18481 char *kwnames[] = {
18482 (char *) "self", NULL
18483 };
18484
18485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18487 if (SWIG_arg_fail(1)) SWIG_fail;
18488 {
18489 PyThreadState* __tstate = wxPyBeginAllowThreads();
18490 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18491
18492 wxPyEndAllowThreads(__tstate);
18493 if (PyErr_Occurred()) SWIG_fail;
18494 }
18495 {
18496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18497 }
18498 return resultobj;
18499 fail:
18500 return NULL;
18501 }
18502
18503
18504 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18505 PyObject *resultobj;
18506 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18507 bool result;
18508 PyObject * obj0 = 0 ;
18509 char *kwnames[] = {
18510 (char *) "self", NULL
18511 };
18512
18513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18515 if (SWIG_arg_fail(1)) SWIG_fail;
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18519
18520 wxPyEndAllowThreads(__tstate);
18521 if (PyErr_Occurred()) SWIG_fail;
18522 }
18523 {
18524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18525 }
18526 return resultobj;
18527 fail:
18528 return NULL;
18529 }
18530
18531
18532 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18533 PyObject *resultobj;
18534 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18535 int result;
18536 PyObject * obj0 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18547
18548 wxPyEndAllowThreads(__tstate);
18549 if (PyErr_Occurred()) SWIG_fail;
18550 }
18551 {
18552 resultobj = SWIG_From_int((int)(result));
18553 }
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18561 PyObject *resultobj;
18562 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18563 int result;
18564 PyObject * obj0 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "self", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18571 if (SWIG_arg_fail(1)) SWIG_fail;
18572 {
18573 PyThreadState* __tstate = wxPyBeginAllowThreads();
18574 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18575
18576 wxPyEndAllowThreads(__tstate);
18577 if (PyErr_Occurred()) SWIG_fail;
18578 }
18579 {
18580 resultobj = SWIG_From_int((int)(result));
18581 }
18582 return resultobj;
18583 fail:
18584 return NULL;
18585 }
18586
18587
18588 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj;
18590 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18591 unsigned int result;
18592 PyObject * obj0 = 0 ;
18593 char *kwnames[] = {
18594 (char *) "self", NULL
18595 };
18596
18597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18599 if (SWIG_arg_fail(1)) SWIG_fail;
18600 {
18601 PyThreadState* __tstate = wxPyBeginAllowThreads();
18602 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18603
18604 wxPyEndAllowThreads(__tstate);
18605 if (PyErr_Occurred()) SWIG_fail;
18606 }
18607 {
18608 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18609 }
18610 return resultobj;
18611 fail:
18612 return NULL;
18613 }
18614
18615
18616 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18617 PyObject *resultobj;
18618 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18619 unsigned int result;
18620 PyObject * obj0 = 0 ;
18621 char *kwnames[] = {
18622 (char *) "self", NULL
18623 };
18624
18625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18627 if (SWIG_arg_fail(1)) SWIG_fail;
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18631
18632 wxPyEndAllowThreads(__tstate);
18633 if (PyErr_Occurred()) SWIG_fail;
18634 }
18635 {
18636 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18637 }
18638 return resultobj;
18639 fail:
18640 return NULL;
18641 }
18642
18643
18644 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18645 PyObject *resultobj;
18646 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18647 wxPoint result;
18648 PyObject * obj0 = 0 ;
18649 char *kwnames[] = {
18650 (char *) "self", NULL
18651 };
18652
18653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18655 if (SWIG_arg_fail(1)) SWIG_fail;
18656 {
18657 PyThreadState* __tstate = wxPyBeginAllowThreads();
18658 result = (arg1)->GetPosition();
18659
18660 wxPyEndAllowThreads(__tstate);
18661 if (PyErr_Occurred()) SWIG_fail;
18662 }
18663 {
18664 wxPoint * resultptr;
18665 resultptr = new wxPoint((wxPoint &)(result));
18666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18667 }
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj;
18676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18677 long *arg2 = (long *) 0 ;
18678 long *arg3 = (long *) 0 ;
18679 long temp2 ;
18680 int res2 = 0 ;
18681 long temp3 ;
18682 int res3 = 0 ;
18683 PyObject * obj0 = 0 ;
18684 char *kwnames[] = {
18685 (char *) "self", NULL
18686 };
18687
18688 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18689 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18692 if (SWIG_arg_fail(1)) SWIG_fail;
18693 {
18694 PyThreadState* __tstate = wxPyBeginAllowThreads();
18695 (arg1)->GetPosition(arg2,arg3);
18696
18697 wxPyEndAllowThreads(__tstate);
18698 if (PyErr_Occurred()) SWIG_fail;
18699 }
18700 Py_INCREF(Py_None); resultobj = Py_None;
18701 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18702 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18703 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18704 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18705 return resultobj;
18706 fail:
18707 return NULL;
18708 }
18709
18710
18711 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18712 PyObject *resultobj;
18713 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18714 int result;
18715 PyObject * obj0 = 0 ;
18716 char *kwnames[] = {
18717 (char *) "self", NULL
18718 };
18719
18720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18722 if (SWIG_arg_fail(1)) SWIG_fail;
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (int)((wxKeyEvent const *)arg1)->GetX();
18726
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 {
18731 resultobj = SWIG_From_int((int)(result));
18732 }
18733 return resultobj;
18734 fail:
18735 return NULL;
18736 }
18737
18738
18739 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj;
18741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18742 int result;
18743 PyObject * obj0 = 0 ;
18744 char *kwnames[] = {
18745 (char *) "self", NULL
18746 };
18747
18748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18750 if (SWIG_arg_fail(1)) SWIG_fail;
18751 {
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 result = (int)((wxKeyEvent const *)arg1)->GetY();
18754
18755 wxPyEndAllowThreads(__tstate);
18756 if (PyErr_Occurred()) SWIG_fail;
18757 }
18758 {
18759 resultobj = SWIG_From_int((int)(result));
18760 }
18761 return resultobj;
18762 fail:
18763 return NULL;
18764 }
18765
18766
18767 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18768 PyObject *resultobj;
18769 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18770 int arg2 ;
18771 PyObject * obj0 = 0 ;
18772 PyObject * obj1 = 0 ;
18773 char *kwnames[] = {
18774 (char *) "self",(char *) "m_x", NULL
18775 };
18776
18777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18779 if (SWIG_arg_fail(1)) SWIG_fail;
18780 {
18781 arg2 = (int)(SWIG_As_int(obj1));
18782 if (SWIG_arg_fail(2)) SWIG_fail;
18783 }
18784 if (arg1) (arg1)->m_x = arg2;
18785
18786 Py_INCREF(Py_None); resultobj = Py_None;
18787 return resultobj;
18788 fail:
18789 return NULL;
18790 }
18791
18792
18793 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18794 PyObject *resultobj;
18795 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18796 int result;
18797 PyObject * obj0 = 0 ;
18798 char *kwnames[] = {
18799 (char *) "self", NULL
18800 };
18801
18802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18804 if (SWIG_arg_fail(1)) SWIG_fail;
18805 result = (int) ((arg1)->m_x);
18806
18807 {
18808 resultobj = SWIG_From_int((int)(result));
18809 }
18810 return resultobj;
18811 fail:
18812 return NULL;
18813 }
18814
18815
18816 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18817 PyObject *resultobj;
18818 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18819 int arg2 ;
18820 PyObject * obj0 = 0 ;
18821 PyObject * obj1 = 0 ;
18822 char *kwnames[] = {
18823 (char *) "self",(char *) "m_y", NULL
18824 };
18825
18826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18828 if (SWIG_arg_fail(1)) SWIG_fail;
18829 {
18830 arg2 = (int)(SWIG_As_int(obj1));
18831 if (SWIG_arg_fail(2)) SWIG_fail;
18832 }
18833 if (arg1) (arg1)->m_y = arg2;
18834
18835 Py_INCREF(Py_None); resultobj = Py_None;
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj;
18844 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18845 int result;
18846 PyObject * obj0 = 0 ;
18847 char *kwnames[] = {
18848 (char *) "self", NULL
18849 };
18850
18851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18853 if (SWIG_arg_fail(1)) SWIG_fail;
18854 result = (int) ((arg1)->m_y);
18855
18856 {
18857 resultobj = SWIG_From_int((int)(result));
18858 }
18859 return resultobj;
18860 fail:
18861 return NULL;
18862 }
18863
18864
18865 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18866 PyObject *resultobj;
18867 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18868 long arg2 ;
18869 PyObject * obj0 = 0 ;
18870 PyObject * obj1 = 0 ;
18871 char *kwnames[] = {
18872 (char *) "self",(char *) "m_keyCode", NULL
18873 };
18874
18875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18877 if (SWIG_arg_fail(1)) SWIG_fail;
18878 {
18879 arg2 = (long)(SWIG_As_long(obj1));
18880 if (SWIG_arg_fail(2)) SWIG_fail;
18881 }
18882 if (arg1) (arg1)->m_keyCode = arg2;
18883
18884 Py_INCREF(Py_None); resultobj = Py_None;
18885 return resultobj;
18886 fail:
18887 return NULL;
18888 }
18889
18890
18891 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18892 PyObject *resultobj;
18893 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18894 long result;
18895 PyObject * obj0 = 0 ;
18896 char *kwnames[] = {
18897 (char *) "self", NULL
18898 };
18899
18900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18902 if (SWIG_arg_fail(1)) SWIG_fail;
18903 result = (long) ((arg1)->m_keyCode);
18904
18905 {
18906 resultobj = SWIG_From_long((long)(result));
18907 }
18908 return resultobj;
18909 fail:
18910 return NULL;
18911 }
18912
18913
18914 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18915 PyObject *resultobj;
18916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18917 bool arg2 ;
18918 PyObject * obj0 = 0 ;
18919 PyObject * obj1 = 0 ;
18920 char *kwnames[] = {
18921 (char *) "self",(char *) "m_controlDown", NULL
18922 };
18923
18924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18926 if (SWIG_arg_fail(1)) SWIG_fail;
18927 {
18928 arg2 = (bool)(SWIG_As_bool(obj1));
18929 if (SWIG_arg_fail(2)) SWIG_fail;
18930 }
18931 if (arg1) (arg1)->m_controlDown = arg2;
18932
18933 Py_INCREF(Py_None); resultobj = Py_None;
18934 return resultobj;
18935 fail:
18936 return NULL;
18937 }
18938
18939
18940 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18941 PyObject *resultobj;
18942 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18943 bool result;
18944 PyObject * obj0 = 0 ;
18945 char *kwnames[] = {
18946 (char *) "self", NULL
18947 };
18948
18949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18951 if (SWIG_arg_fail(1)) SWIG_fail;
18952 result = (bool) ((arg1)->m_controlDown);
18953
18954 {
18955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18956 }
18957 return resultobj;
18958 fail:
18959 return NULL;
18960 }
18961
18962
18963 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18964 PyObject *resultobj;
18965 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18966 bool arg2 ;
18967 PyObject * obj0 = 0 ;
18968 PyObject * obj1 = 0 ;
18969 char *kwnames[] = {
18970 (char *) "self",(char *) "m_shiftDown", NULL
18971 };
18972
18973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18975 if (SWIG_arg_fail(1)) SWIG_fail;
18976 {
18977 arg2 = (bool)(SWIG_As_bool(obj1));
18978 if (SWIG_arg_fail(2)) SWIG_fail;
18979 }
18980 if (arg1) (arg1)->m_shiftDown = arg2;
18981
18982 Py_INCREF(Py_None); resultobj = Py_None;
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18990 PyObject *resultobj;
18991 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18992 bool result;
18993 PyObject * obj0 = 0 ;
18994 char *kwnames[] = {
18995 (char *) "self", NULL
18996 };
18997
18998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19000 if (SWIG_arg_fail(1)) SWIG_fail;
19001 result = (bool) ((arg1)->m_shiftDown);
19002
19003 {
19004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19005 }
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj;
19014 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19015 bool arg2 ;
19016 PyObject * obj0 = 0 ;
19017 PyObject * obj1 = 0 ;
19018 char *kwnames[] = {
19019 (char *) "self",(char *) "m_altDown", NULL
19020 };
19021
19022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19024 if (SWIG_arg_fail(1)) SWIG_fail;
19025 {
19026 arg2 = (bool)(SWIG_As_bool(obj1));
19027 if (SWIG_arg_fail(2)) SWIG_fail;
19028 }
19029 if (arg1) (arg1)->m_altDown = arg2;
19030
19031 Py_INCREF(Py_None); resultobj = Py_None;
19032 return resultobj;
19033 fail:
19034 return NULL;
19035 }
19036
19037
19038 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19039 PyObject *resultobj;
19040 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19041 bool result;
19042 PyObject * obj0 = 0 ;
19043 char *kwnames[] = {
19044 (char *) "self", NULL
19045 };
19046
19047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19049 if (SWIG_arg_fail(1)) SWIG_fail;
19050 result = (bool) ((arg1)->m_altDown);
19051
19052 {
19053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19054 }
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19062 PyObject *resultobj;
19063 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19064 bool arg2 ;
19065 PyObject * obj0 = 0 ;
19066 PyObject * obj1 = 0 ;
19067 char *kwnames[] = {
19068 (char *) "self",(char *) "m_metaDown", NULL
19069 };
19070
19071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19073 if (SWIG_arg_fail(1)) SWIG_fail;
19074 {
19075 arg2 = (bool)(SWIG_As_bool(obj1));
19076 if (SWIG_arg_fail(2)) SWIG_fail;
19077 }
19078 if (arg1) (arg1)->m_metaDown = arg2;
19079
19080 Py_INCREF(Py_None); resultobj = Py_None;
19081 return resultobj;
19082 fail:
19083 return NULL;
19084 }
19085
19086
19087 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19088 PyObject *resultobj;
19089 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19090 bool result;
19091 PyObject * obj0 = 0 ;
19092 char *kwnames[] = {
19093 (char *) "self", NULL
19094 };
19095
19096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19098 if (SWIG_arg_fail(1)) SWIG_fail;
19099 result = (bool) ((arg1)->m_metaDown);
19100
19101 {
19102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19103 }
19104 return resultobj;
19105 fail:
19106 return NULL;
19107 }
19108
19109
19110 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19111 PyObject *resultobj;
19112 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19113 bool arg2 ;
19114 PyObject * obj0 = 0 ;
19115 PyObject * obj1 = 0 ;
19116 char *kwnames[] = {
19117 (char *) "self",(char *) "m_scanCode", NULL
19118 };
19119
19120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19122 if (SWIG_arg_fail(1)) SWIG_fail;
19123 {
19124 arg2 = (bool)(SWIG_As_bool(obj1));
19125 if (SWIG_arg_fail(2)) SWIG_fail;
19126 }
19127 if (arg1) (arg1)->m_scanCode = arg2;
19128
19129 Py_INCREF(Py_None); resultobj = Py_None;
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19139 bool result;
19140 PyObject * obj0 = 0 ;
19141 char *kwnames[] = {
19142 (char *) "self", NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19147 if (SWIG_arg_fail(1)) SWIG_fail;
19148 result = (bool) ((arg1)->m_scanCode);
19149
19150 {
19151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19152 }
19153 return resultobj;
19154 fail:
19155 return NULL;
19156 }
19157
19158
19159 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19160 PyObject *resultobj;
19161 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19162 unsigned int arg2 ;
19163 PyObject * obj0 = 0 ;
19164 PyObject * obj1 = 0 ;
19165 char *kwnames[] = {
19166 (char *) "self",(char *) "m_rawCode", NULL
19167 };
19168
19169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19171 if (SWIG_arg_fail(1)) SWIG_fail;
19172 {
19173 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19174 if (SWIG_arg_fail(2)) SWIG_fail;
19175 }
19176 if (arg1) (arg1)->m_rawCode = arg2;
19177
19178 Py_INCREF(Py_None); resultobj = Py_None;
19179 return resultobj;
19180 fail:
19181 return NULL;
19182 }
19183
19184
19185 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19186 PyObject *resultobj;
19187 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19188 unsigned int result;
19189 PyObject * obj0 = 0 ;
19190 char *kwnames[] = {
19191 (char *) "self", NULL
19192 };
19193
19194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19196 if (SWIG_arg_fail(1)) SWIG_fail;
19197 result = (unsigned int) ((arg1)->m_rawCode);
19198
19199 {
19200 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19201 }
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19211 unsigned int arg2 ;
19212 PyObject * obj0 = 0 ;
19213 PyObject * obj1 = 0 ;
19214 char *kwnames[] = {
19215 (char *) "self",(char *) "m_rawFlags", NULL
19216 };
19217
19218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19220 if (SWIG_arg_fail(1)) SWIG_fail;
19221 {
19222 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19223 if (SWIG_arg_fail(2)) SWIG_fail;
19224 }
19225 if (arg1) (arg1)->m_rawFlags = arg2;
19226
19227 Py_INCREF(Py_None); resultobj = Py_None;
19228 return resultobj;
19229 fail:
19230 return NULL;
19231 }
19232
19233
19234 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19235 PyObject *resultobj;
19236 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19237 unsigned int result;
19238 PyObject * obj0 = 0 ;
19239 char *kwnames[] = {
19240 (char *) "self", NULL
19241 };
19242
19243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19245 if (SWIG_arg_fail(1)) SWIG_fail;
19246 result = (unsigned int) ((arg1)->m_rawFlags);
19247
19248 {
19249 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19250 }
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19258 PyObject *obj;
19259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19260 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19261 Py_INCREF(obj);
19262 return Py_BuildValue((char *)"");
19263 }
19264 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj;
19266 wxSize const &arg1_defvalue = wxDefaultSize ;
19267 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19268 int arg2 = (int) 0 ;
19269 wxSizeEvent *result;
19270 wxSize temp1 ;
19271 PyObject * obj0 = 0 ;
19272 PyObject * obj1 = 0 ;
19273 char *kwnames[] = {
19274 (char *) "sz",(char *) "winid", NULL
19275 };
19276
19277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19278 if (obj0) {
19279 {
19280 arg1 = &temp1;
19281 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19282 }
19283 }
19284 if (obj1) {
19285 {
19286 arg2 = (int)(SWIG_As_int(obj1));
19287 if (SWIG_arg_fail(2)) SWIG_fail;
19288 }
19289 }
19290 {
19291 PyThreadState* __tstate = wxPyBeginAllowThreads();
19292 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19293
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19298 return resultobj;
19299 fail:
19300 return NULL;
19301 }
19302
19303
19304 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19305 PyObject *resultobj;
19306 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19307 wxSize result;
19308 PyObject * obj0 = 0 ;
19309 char *kwnames[] = {
19310 (char *) "self", NULL
19311 };
19312
19313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19315 if (SWIG_arg_fail(1)) SWIG_fail;
19316 {
19317 PyThreadState* __tstate = wxPyBeginAllowThreads();
19318 result = ((wxSizeEvent const *)arg1)->GetSize();
19319
19320 wxPyEndAllowThreads(__tstate);
19321 if (PyErr_Occurred()) SWIG_fail;
19322 }
19323 {
19324 wxSize * resultptr;
19325 resultptr = new wxSize((wxSize &)(result));
19326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19327 }
19328 return resultobj;
19329 fail:
19330 return NULL;
19331 }
19332
19333
19334 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19335 PyObject *resultobj;
19336 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19337 wxRect result;
19338 PyObject * obj0 = 0 ;
19339 char *kwnames[] = {
19340 (char *) "self", NULL
19341 };
19342
19343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19345 if (SWIG_arg_fail(1)) SWIG_fail;
19346 {
19347 PyThreadState* __tstate = wxPyBeginAllowThreads();
19348 result = ((wxSizeEvent const *)arg1)->GetRect();
19349
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 {
19354 wxRect * resultptr;
19355 resultptr = new wxRect((wxRect &)(result));
19356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19357 }
19358 return resultobj;
19359 fail:
19360 return NULL;
19361 }
19362
19363
19364 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19365 PyObject *resultobj;
19366 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19367 wxRect arg2 ;
19368 PyObject * obj0 = 0 ;
19369 PyObject * obj1 = 0 ;
19370 char *kwnames[] = {
19371 (char *) "self",(char *) "rect", NULL
19372 };
19373
19374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19376 if (SWIG_arg_fail(1)) SWIG_fail;
19377 {
19378 wxRect * argp;
19379 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19380 if (SWIG_arg_fail(2)) SWIG_fail;
19381 if (argp == NULL) {
19382 SWIG_null_ref("wxRect");
19383 }
19384 if (SWIG_arg_fail(2)) SWIG_fail;
19385 arg2 = *argp;
19386 }
19387 {
19388 PyThreadState* __tstate = wxPyBeginAllowThreads();
19389 (arg1)->SetRect(arg2);
19390
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 Py_INCREF(Py_None); resultobj = Py_None;
19395 return resultobj;
19396 fail:
19397 return NULL;
19398 }
19399
19400
19401 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19402 PyObject *resultobj;
19403 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19404 wxSize arg2 ;
19405 PyObject * obj0 = 0 ;
19406 PyObject * obj1 = 0 ;
19407 char *kwnames[] = {
19408 (char *) "self",(char *) "size", NULL
19409 };
19410
19411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19413 if (SWIG_arg_fail(1)) SWIG_fail;
19414 {
19415 wxSize * argp;
19416 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19417 if (SWIG_arg_fail(2)) SWIG_fail;
19418 if (argp == NULL) {
19419 SWIG_null_ref("wxSize");
19420 }
19421 if (SWIG_arg_fail(2)) SWIG_fail;
19422 arg2 = *argp;
19423 }
19424 {
19425 PyThreadState* __tstate = wxPyBeginAllowThreads();
19426 wxSizeEvent_SetSize(arg1,arg2);
19427
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 Py_INCREF(Py_None); resultobj = Py_None;
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19439 PyObject *resultobj;
19440 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19441 wxSize *arg2 = (wxSize *) 0 ;
19442 PyObject * obj0 = 0 ;
19443 PyObject * obj1 = 0 ;
19444 char *kwnames[] = {
19445 (char *) "self",(char *) "m_size", NULL
19446 };
19447
19448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19450 if (SWIG_arg_fail(1)) SWIG_fail;
19451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19452 if (SWIG_arg_fail(2)) SWIG_fail;
19453 if (arg1) (arg1)->m_size = *arg2;
19454
19455 Py_INCREF(Py_None); resultobj = Py_None;
19456 return resultobj;
19457 fail:
19458 return NULL;
19459 }
19460
19461
19462 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19463 PyObject *resultobj;
19464 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19465 wxSize *result;
19466 PyObject * obj0 = 0 ;
19467 char *kwnames[] = {
19468 (char *) "self", NULL
19469 };
19470
19471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19473 if (SWIG_arg_fail(1)) SWIG_fail;
19474 result = (wxSize *)& ((arg1)->m_size);
19475
19476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19484 PyObject *resultobj;
19485 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19486 wxRect *arg2 = (wxRect *) 0 ;
19487 PyObject * obj0 = 0 ;
19488 PyObject * obj1 = 0 ;
19489 char *kwnames[] = {
19490 (char *) "self",(char *) "m_rect", NULL
19491 };
19492
19493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19495 if (SWIG_arg_fail(1)) SWIG_fail;
19496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19497 if (SWIG_arg_fail(2)) SWIG_fail;
19498 if (arg1) (arg1)->m_rect = *arg2;
19499
19500 Py_INCREF(Py_None); resultobj = Py_None;
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19508 PyObject *resultobj;
19509 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19510 wxRect *result;
19511 PyObject * obj0 = 0 ;
19512 char *kwnames[] = {
19513 (char *) "self", NULL
19514 };
19515
19516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19518 if (SWIG_arg_fail(1)) SWIG_fail;
19519 result = (wxRect *)& ((arg1)->m_rect);
19520
19521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19522 return resultobj;
19523 fail:
19524 return NULL;
19525 }
19526
19527
19528 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19529 PyObject *obj;
19530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19531 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19532 Py_INCREF(obj);
19533 return Py_BuildValue((char *)"");
19534 }
19535 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19536 PyObject *resultobj;
19537 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19538 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19539 int arg2 = (int) 0 ;
19540 wxMoveEvent *result;
19541 wxPoint temp1 ;
19542 PyObject * obj0 = 0 ;
19543 PyObject * obj1 = 0 ;
19544 char *kwnames[] = {
19545 (char *) "pos",(char *) "winid", NULL
19546 };
19547
19548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19549 if (obj0) {
19550 {
19551 arg1 = &temp1;
19552 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19553 }
19554 }
19555 if (obj1) {
19556 {
19557 arg2 = (int)(SWIG_As_int(obj1));
19558 if (SWIG_arg_fail(2)) SWIG_fail;
19559 }
19560 }
19561 {
19562 PyThreadState* __tstate = wxPyBeginAllowThreads();
19563 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19564
19565 wxPyEndAllowThreads(__tstate);
19566 if (PyErr_Occurred()) SWIG_fail;
19567 }
19568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19569 return resultobj;
19570 fail:
19571 return NULL;
19572 }
19573
19574
19575 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19576 PyObject *resultobj;
19577 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19578 wxPoint result;
19579 PyObject * obj0 = 0 ;
19580 char *kwnames[] = {
19581 (char *) "self", NULL
19582 };
19583
19584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19586 if (SWIG_arg_fail(1)) SWIG_fail;
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 result = ((wxMoveEvent const *)arg1)->GetPosition();
19590
19591 wxPyEndAllowThreads(__tstate);
19592 if (PyErr_Occurred()) SWIG_fail;
19593 }
19594 {
19595 wxPoint * resultptr;
19596 resultptr = new wxPoint((wxPoint &)(result));
19597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19598 }
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19606 PyObject *resultobj;
19607 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19608 wxRect result;
19609 PyObject * obj0 = 0 ;
19610 char *kwnames[] = {
19611 (char *) "self", NULL
19612 };
19613
19614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19616 if (SWIG_arg_fail(1)) SWIG_fail;
19617 {
19618 PyThreadState* __tstate = wxPyBeginAllowThreads();
19619 result = ((wxMoveEvent const *)arg1)->GetRect();
19620
19621 wxPyEndAllowThreads(__tstate);
19622 if (PyErr_Occurred()) SWIG_fail;
19623 }
19624 {
19625 wxRect * resultptr;
19626 resultptr = new wxRect((wxRect &)(result));
19627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19628 }
19629 return resultobj;
19630 fail:
19631 return NULL;
19632 }
19633
19634
19635 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19636 PyObject *resultobj;
19637 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19638 wxRect *arg2 = 0 ;
19639 wxRect temp2 ;
19640 PyObject * obj0 = 0 ;
19641 PyObject * obj1 = 0 ;
19642 char *kwnames[] = {
19643 (char *) "self",(char *) "rect", NULL
19644 };
19645
19646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19648 if (SWIG_arg_fail(1)) SWIG_fail;
19649 {
19650 arg2 = &temp2;
19651 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19652 }
19653 {
19654 PyThreadState* __tstate = wxPyBeginAllowThreads();
19655 (arg1)->SetRect((wxRect const &)*arg2);
19656
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 Py_INCREF(Py_None); resultobj = Py_None;
19661 return resultobj;
19662 fail:
19663 return NULL;
19664 }
19665
19666
19667 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19668 PyObject *resultobj;
19669 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19670 wxPoint *arg2 = 0 ;
19671 wxPoint temp2 ;
19672 PyObject * obj0 = 0 ;
19673 PyObject * obj1 = 0 ;
19674 char *kwnames[] = {
19675 (char *) "self",(char *) "pos", NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19680 if (SWIG_arg_fail(1)) SWIG_fail;
19681 {
19682 arg2 = &temp2;
19683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19684 }
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 (arg1)->SetPosition((wxPoint const &)*arg2);
19688
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 Py_INCREF(Py_None); resultobj = Py_None;
19693 return resultobj;
19694 fail:
19695 return NULL;
19696 }
19697
19698
19699 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19700 PyObject *obj;
19701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19702 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19703 Py_INCREF(obj);
19704 return Py_BuildValue((char *)"");
19705 }
19706 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19707 PyObject *resultobj;
19708 int arg1 = (int) 0 ;
19709 wxPaintEvent *result;
19710 PyObject * obj0 = 0 ;
19711 char *kwnames[] = {
19712 (char *) "Id", NULL
19713 };
19714
19715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19716 if (obj0) {
19717 {
19718 arg1 = (int)(SWIG_As_int(obj0));
19719 if (SWIG_arg_fail(1)) SWIG_fail;
19720 }
19721 }
19722 {
19723 PyThreadState* __tstate = wxPyBeginAllowThreads();
19724 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19725
19726 wxPyEndAllowThreads(__tstate);
19727 if (PyErr_Occurred()) SWIG_fail;
19728 }
19729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19730 return resultobj;
19731 fail:
19732 return NULL;
19733 }
19734
19735
19736 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19737 PyObject *obj;
19738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19739 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19740 Py_INCREF(obj);
19741 return Py_BuildValue((char *)"");
19742 }
19743 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19744 PyObject *resultobj;
19745 int arg1 = (int) 0 ;
19746 wxNcPaintEvent *result;
19747 PyObject * obj0 = 0 ;
19748 char *kwnames[] = {
19749 (char *) "winid", NULL
19750 };
19751
19752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19753 if (obj0) {
19754 {
19755 arg1 = (int)(SWIG_As_int(obj0));
19756 if (SWIG_arg_fail(1)) SWIG_fail;
19757 }
19758 }
19759 {
19760 PyThreadState* __tstate = wxPyBeginAllowThreads();
19761 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19762
19763 wxPyEndAllowThreads(__tstate);
19764 if (PyErr_Occurred()) SWIG_fail;
19765 }
19766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19767 return resultobj;
19768 fail:
19769 return NULL;
19770 }
19771
19772
19773 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19774 PyObject *obj;
19775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19776 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19777 Py_INCREF(obj);
19778 return Py_BuildValue((char *)"");
19779 }
19780 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19781 PyObject *resultobj;
19782 int arg1 = (int) 0 ;
19783 wxDC *arg2 = (wxDC *) NULL ;
19784 wxEraseEvent *result;
19785 PyObject * obj0 = 0 ;
19786 PyObject * obj1 = 0 ;
19787 char *kwnames[] = {
19788 (char *) "Id",(char *) "dc", NULL
19789 };
19790
19791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19792 if (obj0) {
19793 {
19794 arg1 = (int)(SWIG_As_int(obj0));
19795 if (SWIG_arg_fail(1)) SWIG_fail;
19796 }
19797 }
19798 if (obj1) {
19799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19800 if (SWIG_arg_fail(2)) SWIG_fail;
19801 }
19802 {
19803 PyThreadState* __tstate = wxPyBeginAllowThreads();
19804 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19805
19806 wxPyEndAllowThreads(__tstate);
19807 if (PyErr_Occurred()) SWIG_fail;
19808 }
19809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19810 return resultobj;
19811 fail:
19812 return NULL;
19813 }
19814
19815
19816 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj;
19818 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19819 wxDC *result;
19820 PyObject * obj0 = 0 ;
19821 char *kwnames[] = {
19822 (char *) "self", NULL
19823 };
19824
19825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19827 if (SWIG_arg_fail(1)) SWIG_fail;
19828 {
19829 PyThreadState* __tstate = wxPyBeginAllowThreads();
19830 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19831
19832 wxPyEndAllowThreads(__tstate);
19833 if (PyErr_Occurred()) SWIG_fail;
19834 }
19835 {
19836 resultobj = wxPyMake_wxObject(result, 0);
19837 }
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19845 PyObject *obj;
19846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19847 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19848 Py_INCREF(obj);
19849 return Py_BuildValue((char *)"");
19850 }
19851 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj;
19853 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19854 int arg2 = (int) 0 ;
19855 wxFocusEvent *result;
19856 PyObject * obj0 = 0 ;
19857 PyObject * obj1 = 0 ;
19858 char *kwnames[] = {
19859 (char *) "type",(char *) "winid", NULL
19860 };
19861
19862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19863 if (obj0) {
19864 {
19865 arg1 = (wxEventType)(SWIG_As_int(obj0));
19866 if (SWIG_arg_fail(1)) SWIG_fail;
19867 }
19868 }
19869 if (obj1) {
19870 {
19871 arg2 = (int)(SWIG_As_int(obj1));
19872 if (SWIG_arg_fail(2)) SWIG_fail;
19873 }
19874 }
19875 {
19876 PyThreadState* __tstate = wxPyBeginAllowThreads();
19877 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19878
19879 wxPyEndAllowThreads(__tstate);
19880 if (PyErr_Occurred()) SWIG_fail;
19881 }
19882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19883 return resultobj;
19884 fail:
19885 return NULL;
19886 }
19887
19888
19889 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19890 PyObject *resultobj;
19891 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19892 wxWindow *result;
19893 PyObject * obj0 = 0 ;
19894 char *kwnames[] = {
19895 (char *) "self", NULL
19896 };
19897
19898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19900 if (SWIG_arg_fail(1)) SWIG_fail;
19901 {
19902 PyThreadState* __tstate = wxPyBeginAllowThreads();
19903 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19904
19905 wxPyEndAllowThreads(__tstate);
19906 if (PyErr_Occurred()) SWIG_fail;
19907 }
19908 {
19909 resultobj = wxPyMake_wxObject(result, 0);
19910 }
19911 return resultobj;
19912 fail:
19913 return NULL;
19914 }
19915
19916
19917 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19918 PyObject *resultobj;
19919 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19920 wxWindow *arg2 = (wxWindow *) 0 ;
19921 PyObject * obj0 = 0 ;
19922 PyObject * obj1 = 0 ;
19923 char *kwnames[] = {
19924 (char *) "self",(char *) "win", NULL
19925 };
19926
19927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19929 if (SWIG_arg_fail(1)) SWIG_fail;
19930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19931 if (SWIG_arg_fail(2)) SWIG_fail;
19932 {
19933 PyThreadState* __tstate = wxPyBeginAllowThreads();
19934 (arg1)->SetWindow(arg2);
19935
19936 wxPyEndAllowThreads(__tstate);
19937 if (PyErr_Occurred()) SWIG_fail;
19938 }
19939 Py_INCREF(Py_None); resultobj = Py_None;
19940 return resultobj;
19941 fail:
19942 return NULL;
19943 }
19944
19945
19946 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19947 PyObject *obj;
19948 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19949 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19950 Py_INCREF(obj);
19951 return Py_BuildValue((char *)"");
19952 }
19953 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj;
19955 wxWindow *arg1 = (wxWindow *) NULL ;
19956 wxChildFocusEvent *result;
19957 PyObject * obj0 = 0 ;
19958 char *kwnames[] = {
19959 (char *) "win", NULL
19960 };
19961
19962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19963 if (obj0) {
19964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19965 if (SWIG_arg_fail(1)) SWIG_fail;
19966 }
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19970
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19982 PyObject *resultobj;
19983 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19984 wxWindow *result;
19985 PyObject * obj0 = 0 ;
19986 char *kwnames[] = {
19987 (char *) "self", NULL
19988 };
19989
19990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19992 if (SWIG_arg_fail(1)) SWIG_fail;
19993 {
19994 PyThreadState* __tstate = wxPyBeginAllowThreads();
19995 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19996
19997 wxPyEndAllowThreads(__tstate);
19998 if (PyErr_Occurred()) SWIG_fail;
19999 }
20000 {
20001 resultobj = wxPyMake_wxObject(result, 0);
20002 }
20003 return resultobj;
20004 fail:
20005 return NULL;
20006 }
20007
20008
20009 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20010 PyObject *obj;
20011 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20012 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20013 Py_INCREF(obj);
20014 return Py_BuildValue((char *)"");
20015 }
20016 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20017 PyObject *resultobj;
20018 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20019 bool arg2 = (bool) true ;
20020 int arg3 = (int) 0 ;
20021 wxActivateEvent *result;
20022 PyObject * obj0 = 0 ;
20023 PyObject * obj1 = 0 ;
20024 PyObject * obj2 = 0 ;
20025 char *kwnames[] = {
20026 (char *) "type",(char *) "active",(char *) "Id", NULL
20027 };
20028
20029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20030 if (obj0) {
20031 {
20032 arg1 = (wxEventType)(SWIG_As_int(obj0));
20033 if (SWIG_arg_fail(1)) SWIG_fail;
20034 }
20035 }
20036 if (obj1) {
20037 {
20038 arg2 = (bool)(SWIG_As_bool(obj1));
20039 if (SWIG_arg_fail(2)) SWIG_fail;
20040 }
20041 }
20042 if (obj2) {
20043 {
20044 arg3 = (int)(SWIG_As_int(obj2));
20045 if (SWIG_arg_fail(3)) SWIG_fail;
20046 }
20047 }
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20051
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20063 PyObject *resultobj;
20064 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20065 bool result;
20066 PyObject * obj0 = 0 ;
20067 char *kwnames[] = {
20068 (char *) "self", NULL
20069 };
20070
20071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20073 if (SWIG_arg_fail(1)) SWIG_fail;
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20077
20078 wxPyEndAllowThreads(__tstate);
20079 if (PyErr_Occurred()) SWIG_fail;
20080 }
20081 {
20082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20083 }
20084 return resultobj;
20085 fail:
20086 return NULL;
20087 }
20088
20089
20090 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20091 PyObject *obj;
20092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20093 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20094 Py_INCREF(obj);
20095 return Py_BuildValue((char *)"");
20096 }
20097 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20098 PyObject *resultobj;
20099 int arg1 = (int) 0 ;
20100 wxInitDialogEvent *result;
20101 PyObject * obj0 = 0 ;
20102 char *kwnames[] = {
20103 (char *) "Id", NULL
20104 };
20105
20106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20107 if (obj0) {
20108 {
20109 arg1 = (int)(SWIG_As_int(obj0));
20110 if (SWIG_arg_fail(1)) SWIG_fail;
20111 }
20112 }
20113 {
20114 PyThreadState* __tstate = wxPyBeginAllowThreads();
20115 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20116
20117 wxPyEndAllowThreads(__tstate);
20118 if (PyErr_Occurred()) SWIG_fail;
20119 }
20120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20121 return resultobj;
20122 fail:
20123 return NULL;
20124 }
20125
20126
20127 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20128 PyObject *obj;
20129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20130 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20131 Py_INCREF(obj);
20132 return Py_BuildValue((char *)"");
20133 }
20134 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20135 PyObject *resultobj;
20136 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20137 int arg2 = (int) 0 ;
20138 wxMenu *arg3 = (wxMenu *) NULL ;
20139 wxMenuEvent *result;
20140 PyObject * obj0 = 0 ;
20141 PyObject * obj1 = 0 ;
20142 PyObject * obj2 = 0 ;
20143 char *kwnames[] = {
20144 (char *) "type",(char *) "winid",(char *) "menu", NULL
20145 };
20146
20147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20148 if (obj0) {
20149 {
20150 arg1 = (wxEventType)(SWIG_As_int(obj0));
20151 if (SWIG_arg_fail(1)) SWIG_fail;
20152 }
20153 }
20154 if (obj1) {
20155 {
20156 arg2 = (int)(SWIG_As_int(obj1));
20157 if (SWIG_arg_fail(2)) SWIG_fail;
20158 }
20159 }
20160 if (obj2) {
20161 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20162 if (SWIG_arg_fail(3)) SWIG_fail;
20163 }
20164 {
20165 PyThreadState* __tstate = wxPyBeginAllowThreads();
20166 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20167
20168 wxPyEndAllowThreads(__tstate);
20169 if (PyErr_Occurred()) SWIG_fail;
20170 }
20171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20172 return resultobj;
20173 fail:
20174 return NULL;
20175 }
20176
20177
20178 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20179 PyObject *resultobj;
20180 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20181 int result;
20182 PyObject * obj0 = 0 ;
20183 char *kwnames[] = {
20184 (char *) "self", NULL
20185 };
20186
20187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20189 if (SWIG_arg_fail(1)) SWIG_fail;
20190 {
20191 PyThreadState* __tstate = wxPyBeginAllowThreads();
20192 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20193
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 {
20198 resultobj = SWIG_From_int((int)(result));
20199 }
20200 return resultobj;
20201 fail:
20202 return NULL;
20203 }
20204
20205
20206 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20207 PyObject *resultobj;
20208 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20209 bool result;
20210 PyObject * obj0 = 0 ;
20211 char *kwnames[] = {
20212 (char *) "self", NULL
20213 };
20214
20215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20217 if (SWIG_arg_fail(1)) SWIG_fail;
20218 {
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20221
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 {
20226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20227 }
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20235 PyObject *resultobj;
20236 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20237 wxMenu *result;
20238 PyObject * obj0 = 0 ;
20239 char *kwnames[] = {
20240 (char *) "self", NULL
20241 };
20242
20243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20245 if (SWIG_arg_fail(1)) SWIG_fail;
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20249
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 {
20254 resultobj = wxPyMake_wxObject(result, 0);
20255 }
20256 return resultobj;
20257 fail:
20258 return NULL;
20259 }
20260
20261
20262 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20263 PyObject *obj;
20264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20265 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20266 Py_INCREF(obj);
20267 return Py_BuildValue((char *)"");
20268 }
20269 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj;
20271 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20272 int arg2 = (int) 0 ;
20273 wxCloseEvent *result;
20274 PyObject * obj0 = 0 ;
20275 PyObject * obj1 = 0 ;
20276 char *kwnames[] = {
20277 (char *) "type",(char *) "winid", NULL
20278 };
20279
20280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20281 if (obj0) {
20282 {
20283 arg1 = (wxEventType)(SWIG_As_int(obj0));
20284 if (SWIG_arg_fail(1)) SWIG_fail;
20285 }
20286 }
20287 if (obj1) {
20288 {
20289 arg2 = (int)(SWIG_As_int(obj1));
20290 if (SWIG_arg_fail(2)) SWIG_fail;
20291 }
20292 }
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20296
20297 wxPyEndAllowThreads(__tstate);
20298 if (PyErr_Occurred()) SWIG_fail;
20299 }
20300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20301 return resultobj;
20302 fail:
20303 return NULL;
20304 }
20305
20306
20307 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20308 PyObject *resultobj;
20309 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20310 bool arg2 ;
20311 PyObject * obj0 = 0 ;
20312 PyObject * obj1 = 0 ;
20313 char *kwnames[] = {
20314 (char *) "self",(char *) "logOff", NULL
20315 };
20316
20317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20319 if (SWIG_arg_fail(1)) SWIG_fail;
20320 {
20321 arg2 = (bool)(SWIG_As_bool(obj1));
20322 if (SWIG_arg_fail(2)) SWIG_fail;
20323 }
20324 {
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 (arg1)->SetLoggingOff(arg2);
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 Py_INCREF(Py_None); resultobj = Py_None;
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20339 PyObject *resultobj;
20340 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20341 bool result;
20342 PyObject * obj0 = 0 ;
20343 char *kwnames[] = {
20344 (char *) "self", NULL
20345 };
20346
20347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20349 if (SWIG_arg_fail(1)) SWIG_fail;
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20353
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 {
20358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20359 }
20360 return resultobj;
20361 fail:
20362 return NULL;
20363 }
20364
20365
20366 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20367 PyObject *resultobj;
20368 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20369 bool arg2 = (bool) true ;
20370 PyObject * obj0 = 0 ;
20371 PyObject * obj1 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self",(char *) "veto", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20378 if (SWIG_arg_fail(1)) SWIG_fail;
20379 if (obj1) {
20380 {
20381 arg2 = (bool)(SWIG_As_bool(obj1));
20382 if (SWIG_arg_fail(2)) SWIG_fail;
20383 }
20384 }
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 (arg1)->Veto(arg2);
20388
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 Py_INCREF(Py_None); resultobj = Py_None;
20393 return resultobj;
20394 fail:
20395 return NULL;
20396 }
20397
20398
20399 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20400 PyObject *resultobj;
20401 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20402 bool result;
20403 PyObject * obj0 = 0 ;
20404 char *kwnames[] = {
20405 (char *) "self", NULL
20406 };
20407
20408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20410 if (SWIG_arg_fail(1)) SWIG_fail;
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20414
20415 wxPyEndAllowThreads(__tstate);
20416 if (PyErr_Occurred()) SWIG_fail;
20417 }
20418 {
20419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj;
20429 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20430 bool arg2 ;
20431 PyObject * obj0 = 0 ;
20432 PyObject * obj1 = 0 ;
20433 char *kwnames[] = {
20434 (char *) "self",(char *) "canVeto", NULL
20435 };
20436
20437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20439 if (SWIG_arg_fail(1)) SWIG_fail;
20440 {
20441 arg2 = (bool)(SWIG_As_bool(obj1));
20442 if (SWIG_arg_fail(2)) SWIG_fail;
20443 }
20444 {
20445 PyThreadState* __tstate = wxPyBeginAllowThreads();
20446 (arg1)->SetCanVeto(arg2);
20447
20448 wxPyEndAllowThreads(__tstate);
20449 if (PyErr_Occurred()) SWIG_fail;
20450 }
20451 Py_INCREF(Py_None); resultobj = Py_None;
20452 return resultobj;
20453 fail:
20454 return NULL;
20455 }
20456
20457
20458 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20459 PyObject *resultobj;
20460 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20461 bool result;
20462 PyObject * obj0 = 0 ;
20463 char *kwnames[] = {
20464 (char *) "self", NULL
20465 };
20466
20467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20469 if (SWIG_arg_fail(1)) SWIG_fail;
20470 {
20471 PyThreadState* __tstate = wxPyBeginAllowThreads();
20472 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20473
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 {
20478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20479 }
20480 return resultobj;
20481 fail:
20482 return NULL;
20483 }
20484
20485
20486 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20487 PyObject *obj;
20488 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20489 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20490 Py_INCREF(obj);
20491 return Py_BuildValue((char *)"");
20492 }
20493 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20494 PyObject *resultobj;
20495 int arg1 = (int) 0 ;
20496 bool arg2 = (bool) false ;
20497 wxShowEvent *result;
20498 PyObject * obj0 = 0 ;
20499 PyObject * obj1 = 0 ;
20500 char *kwnames[] = {
20501 (char *) "winid",(char *) "show", NULL
20502 };
20503
20504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20505 if (obj0) {
20506 {
20507 arg1 = (int)(SWIG_As_int(obj0));
20508 if (SWIG_arg_fail(1)) SWIG_fail;
20509 }
20510 }
20511 if (obj1) {
20512 {
20513 arg2 = (bool)(SWIG_As_bool(obj1));
20514 if (SWIG_arg_fail(2)) SWIG_fail;
20515 }
20516 }
20517 {
20518 PyThreadState* __tstate = wxPyBeginAllowThreads();
20519 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20520
20521 wxPyEndAllowThreads(__tstate);
20522 if (PyErr_Occurred()) SWIG_fail;
20523 }
20524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20525 return resultobj;
20526 fail:
20527 return NULL;
20528 }
20529
20530
20531 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20532 PyObject *resultobj;
20533 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20534 bool arg2 ;
20535 PyObject * obj0 = 0 ;
20536 PyObject * obj1 = 0 ;
20537 char *kwnames[] = {
20538 (char *) "self",(char *) "show", NULL
20539 };
20540
20541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20543 if (SWIG_arg_fail(1)) SWIG_fail;
20544 {
20545 arg2 = (bool)(SWIG_As_bool(obj1));
20546 if (SWIG_arg_fail(2)) SWIG_fail;
20547 }
20548 {
20549 PyThreadState* __tstate = wxPyBeginAllowThreads();
20550 (arg1)->SetShow(arg2);
20551
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 Py_INCREF(Py_None); resultobj = Py_None;
20556 return resultobj;
20557 fail:
20558 return NULL;
20559 }
20560
20561
20562 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20563 PyObject *resultobj;
20564 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20565 bool result;
20566 PyObject * obj0 = 0 ;
20567 char *kwnames[] = {
20568 (char *) "self", NULL
20569 };
20570
20571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20573 if (SWIG_arg_fail(1)) SWIG_fail;
20574 {
20575 PyThreadState* __tstate = wxPyBeginAllowThreads();
20576 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20577
20578 wxPyEndAllowThreads(__tstate);
20579 if (PyErr_Occurred()) SWIG_fail;
20580 }
20581 {
20582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20583 }
20584 return resultobj;
20585 fail:
20586 return NULL;
20587 }
20588
20589
20590 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20591 PyObject *obj;
20592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20593 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20594 Py_INCREF(obj);
20595 return Py_BuildValue((char *)"");
20596 }
20597 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20598 PyObject *resultobj;
20599 int arg1 = (int) 0 ;
20600 bool arg2 = (bool) true ;
20601 wxIconizeEvent *result;
20602 PyObject * obj0 = 0 ;
20603 PyObject * obj1 = 0 ;
20604 char *kwnames[] = {
20605 (char *) "id",(char *) "iconized", NULL
20606 };
20607
20608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20609 if (obj0) {
20610 {
20611 arg1 = (int)(SWIG_As_int(obj0));
20612 if (SWIG_arg_fail(1)) SWIG_fail;
20613 }
20614 }
20615 if (obj1) {
20616 {
20617 arg2 = (bool)(SWIG_As_bool(obj1));
20618 if (SWIG_arg_fail(2)) SWIG_fail;
20619 }
20620 }
20621 {
20622 PyThreadState* __tstate = wxPyBeginAllowThreads();
20623 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20624
20625 wxPyEndAllowThreads(__tstate);
20626 if (PyErr_Occurred()) SWIG_fail;
20627 }
20628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20629 return resultobj;
20630 fail:
20631 return NULL;
20632 }
20633
20634
20635 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20636 PyObject *resultobj;
20637 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20638 bool result;
20639 PyObject * obj0 = 0 ;
20640 char *kwnames[] = {
20641 (char *) "self", NULL
20642 };
20643
20644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20646 if (SWIG_arg_fail(1)) SWIG_fail;
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 result = (bool)(arg1)->Iconized();
20650
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 {
20655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20664 PyObject *obj;
20665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20666 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20667 Py_INCREF(obj);
20668 return Py_BuildValue((char *)"");
20669 }
20670 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20671 PyObject *resultobj;
20672 int arg1 = (int) 0 ;
20673 wxMaximizeEvent *result;
20674 PyObject * obj0 = 0 ;
20675 char *kwnames[] = {
20676 (char *) "id", NULL
20677 };
20678
20679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20680 if (obj0) {
20681 {
20682 arg1 = (int)(SWIG_As_int(obj0));
20683 if (SWIG_arg_fail(1)) SWIG_fail;
20684 }
20685 }
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20689
20690 wxPyEndAllowThreads(__tstate);
20691 if (PyErr_Occurred()) SWIG_fail;
20692 }
20693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20694 return resultobj;
20695 fail:
20696 return NULL;
20697 }
20698
20699
20700 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20701 PyObject *obj;
20702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20703 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20704 Py_INCREF(obj);
20705 return Py_BuildValue((char *)"");
20706 }
20707 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20708 PyObject *resultobj;
20709 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20710 wxPoint result;
20711 PyObject * obj0 = 0 ;
20712 char *kwnames[] = {
20713 (char *) "self", NULL
20714 };
20715
20716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20718 if (SWIG_arg_fail(1)) SWIG_fail;
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (arg1)->GetPosition();
20722
20723 wxPyEndAllowThreads(__tstate);
20724 if (PyErr_Occurred()) SWIG_fail;
20725 }
20726 {
20727 wxPoint * resultptr;
20728 resultptr = new wxPoint((wxPoint &)(result));
20729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20730 }
20731 return resultobj;
20732 fail:
20733 return NULL;
20734 }
20735
20736
20737 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20738 PyObject *resultobj;
20739 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20740 int result;
20741 PyObject * obj0 = 0 ;
20742 char *kwnames[] = {
20743 (char *) "self", NULL
20744 };
20745
20746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20748 if (SWIG_arg_fail(1)) SWIG_fail;
20749 {
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 result = (int)(arg1)->GetNumberOfFiles();
20752
20753 wxPyEndAllowThreads(__tstate);
20754 if (PyErr_Occurred()) SWIG_fail;
20755 }
20756 {
20757 resultobj = SWIG_From_int((int)(result));
20758 }
20759 return resultobj;
20760 fail:
20761 return NULL;
20762 }
20763
20764
20765 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20766 PyObject *resultobj;
20767 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20768 PyObject *result;
20769 PyObject * obj0 = 0 ;
20770 char *kwnames[] = {
20771 (char *) "self", NULL
20772 };
20773
20774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20776 if (SWIG_arg_fail(1)) SWIG_fail;
20777 {
20778 PyThreadState* __tstate = wxPyBeginAllowThreads();
20779 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20780
20781 wxPyEndAllowThreads(__tstate);
20782 if (PyErr_Occurred()) SWIG_fail;
20783 }
20784 resultobj = result;
20785 return resultobj;
20786 fail:
20787 return NULL;
20788 }
20789
20790
20791 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20792 PyObject *obj;
20793 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20794 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20795 Py_INCREF(obj);
20796 return Py_BuildValue((char *)"");
20797 }
20798 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj;
20800 int arg1 = (int) 0 ;
20801 wxUpdateUIEvent *result;
20802 PyObject * obj0 = 0 ;
20803 char *kwnames[] = {
20804 (char *) "commandId", NULL
20805 };
20806
20807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20808 if (obj0) {
20809 {
20810 arg1 = (int)(SWIG_As_int(obj0));
20811 if (SWIG_arg_fail(1)) SWIG_fail;
20812 }
20813 }
20814 {
20815 PyThreadState* __tstate = wxPyBeginAllowThreads();
20816 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20817
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20829 PyObject *resultobj;
20830 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20831 bool result;
20832 PyObject * obj0 = 0 ;
20833 char *kwnames[] = {
20834 (char *) "self", NULL
20835 };
20836
20837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20839 if (SWIG_arg_fail(1)) SWIG_fail;
20840 {
20841 PyThreadState* __tstate = wxPyBeginAllowThreads();
20842 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20843
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 {
20848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20849 }
20850 return resultobj;
20851 fail:
20852 return NULL;
20853 }
20854
20855
20856 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20857 PyObject *resultobj;
20858 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20859 bool result;
20860 PyObject * obj0 = 0 ;
20861 char *kwnames[] = {
20862 (char *) "self", NULL
20863 };
20864
20865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20867 if (SWIG_arg_fail(1)) SWIG_fail;
20868 {
20869 PyThreadState* __tstate = wxPyBeginAllowThreads();
20870 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20871
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 {
20876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20877 }
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20885 PyObject *resultobj;
20886 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20887 wxString result;
20888 PyObject * obj0 = 0 ;
20889 char *kwnames[] = {
20890 (char *) "self", NULL
20891 };
20892
20893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20895 if (SWIG_arg_fail(1)) SWIG_fail;
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20899
20900 wxPyEndAllowThreads(__tstate);
20901 if (PyErr_Occurred()) SWIG_fail;
20902 }
20903 {
20904 #if wxUSE_UNICODE
20905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20906 #else
20907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20908 #endif
20909 }
20910 return resultobj;
20911 fail:
20912 return NULL;
20913 }
20914
20915
20916 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20917 PyObject *resultobj;
20918 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20919 bool result;
20920 PyObject * obj0 = 0 ;
20921 char *kwnames[] = {
20922 (char *) "self", NULL
20923 };
20924
20925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20927 if (SWIG_arg_fail(1)) SWIG_fail;
20928 {
20929 PyThreadState* __tstate = wxPyBeginAllowThreads();
20930 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20931
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 {
20936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20937 }
20938 return resultobj;
20939 fail:
20940 return NULL;
20941 }
20942
20943
20944 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20945 PyObject *resultobj;
20946 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20947 bool result;
20948 PyObject * obj0 = 0 ;
20949 char *kwnames[] = {
20950 (char *) "self", NULL
20951 };
20952
20953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20955 if (SWIG_arg_fail(1)) SWIG_fail;
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20959
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 {
20964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20965 }
20966 return resultobj;
20967 fail:
20968 return NULL;
20969 }
20970
20971
20972 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20973 PyObject *resultobj;
20974 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20975 bool result;
20976 PyObject * obj0 = 0 ;
20977 char *kwnames[] = {
20978 (char *) "self", NULL
20979 };
20980
20981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20983 if (SWIG_arg_fail(1)) SWIG_fail;
20984 {
20985 PyThreadState* __tstate = wxPyBeginAllowThreads();
20986 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20987
20988 wxPyEndAllowThreads(__tstate);
20989 if (PyErr_Occurred()) SWIG_fail;
20990 }
20991 {
20992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20993 }
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21001 PyObject *resultobj;
21002 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21003 bool arg2 ;
21004 PyObject * obj0 = 0 ;
21005 PyObject * obj1 = 0 ;
21006 char *kwnames[] = {
21007 (char *) "self",(char *) "check", NULL
21008 };
21009
21010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21012 if (SWIG_arg_fail(1)) SWIG_fail;
21013 {
21014 arg2 = (bool)(SWIG_As_bool(obj1));
21015 if (SWIG_arg_fail(2)) SWIG_fail;
21016 }
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 (arg1)->Check(arg2);
21020
21021 wxPyEndAllowThreads(__tstate);
21022 if (PyErr_Occurred()) SWIG_fail;
21023 }
21024 Py_INCREF(Py_None); resultobj = Py_None;
21025 return resultobj;
21026 fail:
21027 return NULL;
21028 }
21029
21030
21031 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21032 PyObject *resultobj;
21033 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21034 bool arg2 ;
21035 PyObject * obj0 = 0 ;
21036 PyObject * obj1 = 0 ;
21037 char *kwnames[] = {
21038 (char *) "self",(char *) "enable", NULL
21039 };
21040
21041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21043 if (SWIG_arg_fail(1)) SWIG_fail;
21044 {
21045 arg2 = (bool)(SWIG_As_bool(obj1));
21046 if (SWIG_arg_fail(2)) SWIG_fail;
21047 }
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 (arg1)->Enable(arg2);
21051
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 Py_INCREF(Py_None); resultobj = Py_None;
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21063 PyObject *resultobj;
21064 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21065 wxString *arg2 = 0 ;
21066 bool temp2 = false ;
21067 PyObject * obj0 = 0 ;
21068 PyObject * obj1 = 0 ;
21069 char *kwnames[] = {
21070 (char *) "self",(char *) "text", NULL
21071 };
21072
21073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21075 if (SWIG_arg_fail(1)) SWIG_fail;
21076 {
21077 arg2 = wxString_in_helper(obj1);
21078 if (arg2 == NULL) SWIG_fail;
21079 temp2 = true;
21080 }
21081 {
21082 PyThreadState* __tstate = wxPyBeginAllowThreads();
21083 (arg1)->SetText((wxString const &)*arg2);
21084
21085 wxPyEndAllowThreads(__tstate);
21086 if (PyErr_Occurred()) SWIG_fail;
21087 }
21088 Py_INCREF(Py_None); resultobj = Py_None;
21089 {
21090 if (temp2)
21091 delete arg2;
21092 }
21093 return resultobj;
21094 fail:
21095 {
21096 if (temp2)
21097 delete arg2;
21098 }
21099 return NULL;
21100 }
21101
21102
21103 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21104 PyObject *resultobj;
21105 long arg1 ;
21106 PyObject * obj0 = 0 ;
21107 char *kwnames[] = {
21108 (char *) "updateInterval", NULL
21109 };
21110
21111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21112 {
21113 arg1 = (long)(SWIG_As_long(obj0));
21114 if (SWIG_arg_fail(1)) SWIG_fail;
21115 }
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 wxUpdateUIEvent::SetUpdateInterval(arg1);
21119
21120 wxPyEndAllowThreads(__tstate);
21121 if (PyErr_Occurred()) SWIG_fail;
21122 }
21123 Py_INCREF(Py_None); resultobj = Py_None;
21124 return resultobj;
21125 fail:
21126 return NULL;
21127 }
21128
21129
21130 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21131 PyObject *resultobj;
21132 long result;
21133 char *kwnames[] = {
21134 NULL
21135 };
21136
21137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21141
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 {
21146 resultobj = SWIG_From_long((long)(result));
21147 }
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21155 PyObject *resultobj;
21156 wxWindow *arg1 = (wxWindow *) 0 ;
21157 bool result;
21158 PyObject * obj0 = 0 ;
21159 char *kwnames[] = {
21160 (char *) "win", NULL
21161 };
21162
21163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21165 if (SWIG_arg_fail(1)) SWIG_fail;
21166 {
21167 PyThreadState* __tstate = wxPyBeginAllowThreads();
21168 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21169
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 {
21174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21175 }
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21183 PyObject *resultobj;
21184 char *kwnames[] = {
21185 NULL
21186 };
21187
21188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 wxUpdateUIEvent::ResetUpdateTime();
21192
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 Py_INCREF(Py_None); resultobj = Py_None;
21197 return resultobj;
21198 fail:
21199 return NULL;
21200 }
21201
21202
21203 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21204 PyObject *resultobj;
21205 wxUpdateUIMode arg1 ;
21206 PyObject * obj0 = 0 ;
21207 char *kwnames[] = {
21208 (char *) "mode", NULL
21209 };
21210
21211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21212 {
21213 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21214 if (SWIG_arg_fail(1)) SWIG_fail;
21215 }
21216 {
21217 PyThreadState* __tstate = wxPyBeginAllowThreads();
21218 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21219
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 Py_INCREF(Py_None); resultobj = Py_None;
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj;
21232 wxUpdateUIMode result;
21233 char *kwnames[] = {
21234 NULL
21235 };
21236
21237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21238 {
21239 PyThreadState* __tstate = wxPyBeginAllowThreads();
21240 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21241
21242 wxPyEndAllowThreads(__tstate);
21243 if (PyErr_Occurred()) SWIG_fail;
21244 }
21245 resultobj = SWIG_From_int((result));
21246 return resultobj;
21247 fail:
21248 return NULL;
21249 }
21250
21251
21252 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21253 PyObject *obj;
21254 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21255 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21256 Py_INCREF(obj);
21257 return Py_BuildValue((char *)"");
21258 }
21259 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21260 PyObject *resultobj;
21261 wxSysColourChangedEvent *result;
21262 char *kwnames[] = {
21263 NULL
21264 };
21265
21266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21267 {
21268 PyThreadState* __tstate = wxPyBeginAllowThreads();
21269 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21270
21271 wxPyEndAllowThreads(__tstate);
21272 if (PyErr_Occurred()) SWIG_fail;
21273 }
21274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21275 return resultobj;
21276 fail:
21277 return NULL;
21278 }
21279
21280
21281 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21282 PyObject *obj;
21283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21284 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21285 Py_INCREF(obj);
21286 return Py_BuildValue((char *)"");
21287 }
21288 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21289 PyObject *resultobj;
21290 int arg1 = (int) 0 ;
21291 wxWindow *arg2 = (wxWindow *) NULL ;
21292 wxMouseCaptureChangedEvent *result;
21293 PyObject * obj0 = 0 ;
21294 PyObject * obj1 = 0 ;
21295 char *kwnames[] = {
21296 (char *) "winid",(char *) "gainedCapture", NULL
21297 };
21298
21299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21300 if (obj0) {
21301 {
21302 arg1 = (int)(SWIG_As_int(obj0));
21303 if (SWIG_arg_fail(1)) SWIG_fail;
21304 }
21305 }
21306 if (obj1) {
21307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21308 if (SWIG_arg_fail(2)) SWIG_fail;
21309 }
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21313
21314 wxPyEndAllowThreads(__tstate);
21315 if (PyErr_Occurred()) SWIG_fail;
21316 }
21317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21318 return resultobj;
21319 fail:
21320 return NULL;
21321 }
21322
21323
21324 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21325 PyObject *resultobj;
21326 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21327 wxWindow *result;
21328 PyObject * obj0 = 0 ;
21329 char *kwnames[] = {
21330 (char *) "self", NULL
21331 };
21332
21333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21335 if (SWIG_arg_fail(1)) SWIG_fail;
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21339
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 {
21344 resultobj = wxPyMake_wxObject(result, 0);
21345 }
21346 return resultobj;
21347 fail:
21348 return NULL;
21349 }
21350
21351
21352 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21353 PyObject *obj;
21354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21355 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21356 Py_INCREF(obj);
21357 return Py_BuildValue((char *)"");
21358 }
21359 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21360 PyObject *resultobj;
21361 wxDisplayChangedEvent *result;
21362 char *kwnames[] = {
21363 NULL
21364 };
21365
21366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21367 {
21368 PyThreadState* __tstate = wxPyBeginAllowThreads();
21369 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21370
21371 wxPyEndAllowThreads(__tstate);
21372 if (PyErr_Occurred()) SWIG_fail;
21373 }
21374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21375 return resultobj;
21376 fail:
21377 return NULL;
21378 }
21379
21380
21381 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21382 PyObject *obj;
21383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21384 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21385 Py_INCREF(obj);
21386 return Py_BuildValue((char *)"");
21387 }
21388 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21389 PyObject *resultobj;
21390 int arg1 = (int) 0 ;
21391 wxPaletteChangedEvent *result;
21392 PyObject * obj0 = 0 ;
21393 char *kwnames[] = {
21394 (char *) "id", NULL
21395 };
21396
21397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21398 if (obj0) {
21399 {
21400 arg1 = (int)(SWIG_As_int(obj0));
21401 if (SWIG_arg_fail(1)) SWIG_fail;
21402 }
21403 }
21404 {
21405 PyThreadState* __tstate = wxPyBeginAllowThreads();
21406 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21407
21408 wxPyEndAllowThreads(__tstate);
21409 if (PyErr_Occurred()) SWIG_fail;
21410 }
21411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21412 return resultobj;
21413 fail:
21414 return NULL;
21415 }
21416
21417
21418 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21419 PyObject *resultobj;
21420 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21421 wxWindow *arg2 = (wxWindow *) 0 ;
21422 PyObject * obj0 = 0 ;
21423 PyObject * obj1 = 0 ;
21424 char *kwnames[] = {
21425 (char *) "self",(char *) "win", NULL
21426 };
21427
21428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21430 if (SWIG_arg_fail(1)) SWIG_fail;
21431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21432 if (SWIG_arg_fail(2)) SWIG_fail;
21433 {
21434 PyThreadState* __tstate = wxPyBeginAllowThreads();
21435 (arg1)->SetChangedWindow(arg2);
21436
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 Py_INCREF(Py_None); resultobj = Py_None;
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj;
21449 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21450 wxWindow *result;
21451 PyObject * obj0 = 0 ;
21452 char *kwnames[] = {
21453 (char *) "self", NULL
21454 };
21455
21456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21458 if (SWIG_arg_fail(1)) SWIG_fail;
21459 {
21460 PyThreadState* __tstate = wxPyBeginAllowThreads();
21461 result = (wxWindow *)(arg1)->GetChangedWindow();
21462
21463 wxPyEndAllowThreads(__tstate);
21464 if (PyErr_Occurred()) SWIG_fail;
21465 }
21466 {
21467 resultobj = wxPyMake_wxObject(result, 0);
21468 }
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21476 PyObject *obj;
21477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21478 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21479 Py_INCREF(obj);
21480 return Py_BuildValue((char *)"");
21481 }
21482 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj;
21484 int arg1 = (int) 0 ;
21485 wxQueryNewPaletteEvent *result;
21486 PyObject * obj0 = 0 ;
21487 char *kwnames[] = {
21488 (char *) "winid", NULL
21489 };
21490
21491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21492 if (obj0) {
21493 {
21494 arg1 = (int)(SWIG_As_int(obj0));
21495 if (SWIG_arg_fail(1)) SWIG_fail;
21496 }
21497 }
21498 {
21499 PyThreadState* __tstate = wxPyBeginAllowThreads();
21500 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21501
21502 wxPyEndAllowThreads(__tstate);
21503 if (PyErr_Occurred()) SWIG_fail;
21504 }
21505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21506 return resultobj;
21507 fail:
21508 return NULL;
21509 }
21510
21511
21512 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21513 PyObject *resultobj;
21514 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21515 bool arg2 ;
21516 PyObject * obj0 = 0 ;
21517 PyObject * obj1 = 0 ;
21518 char *kwnames[] = {
21519 (char *) "self",(char *) "realized", NULL
21520 };
21521
21522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21524 if (SWIG_arg_fail(1)) SWIG_fail;
21525 {
21526 arg2 = (bool)(SWIG_As_bool(obj1));
21527 if (SWIG_arg_fail(2)) SWIG_fail;
21528 }
21529 {
21530 PyThreadState* __tstate = wxPyBeginAllowThreads();
21531 (arg1)->SetPaletteRealized(arg2);
21532
21533 wxPyEndAllowThreads(__tstate);
21534 if (PyErr_Occurred()) SWIG_fail;
21535 }
21536 Py_INCREF(Py_None); resultobj = Py_None;
21537 return resultobj;
21538 fail:
21539 return NULL;
21540 }
21541
21542
21543 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21544 PyObject *resultobj;
21545 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21546 bool result;
21547 PyObject * obj0 = 0 ;
21548 char *kwnames[] = {
21549 (char *) "self", NULL
21550 };
21551
21552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21554 if (SWIG_arg_fail(1)) SWIG_fail;
21555 {
21556 PyThreadState* __tstate = wxPyBeginAllowThreads();
21557 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21558
21559 wxPyEndAllowThreads(__tstate);
21560 if (PyErr_Occurred()) SWIG_fail;
21561 }
21562 {
21563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21564 }
21565 return resultobj;
21566 fail:
21567 return NULL;
21568 }
21569
21570
21571 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21572 PyObject *obj;
21573 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21574 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21575 Py_INCREF(obj);
21576 return Py_BuildValue((char *)"");
21577 }
21578 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21579 PyObject *resultobj;
21580 wxNavigationKeyEvent *result;
21581 char *kwnames[] = {
21582 NULL
21583 };
21584
21585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21586 {
21587 PyThreadState* __tstate = wxPyBeginAllowThreads();
21588 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21589
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21594 return resultobj;
21595 fail:
21596 return NULL;
21597 }
21598
21599
21600 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21601 PyObject *resultobj;
21602 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21603 bool result;
21604 PyObject * obj0 = 0 ;
21605 char *kwnames[] = {
21606 (char *) "self", NULL
21607 };
21608
21609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21611 if (SWIG_arg_fail(1)) SWIG_fail;
21612 {
21613 PyThreadState* __tstate = wxPyBeginAllowThreads();
21614 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21615
21616 wxPyEndAllowThreads(__tstate);
21617 if (PyErr_Occurred()) SWIG_fail;
21618 }
21619 {
21620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21621 }
21622 return resultobj;
21623 fail:
21624 return NULL;
21625 }
21626
21627
21628 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21629 PyObject *resultobj;
21630 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21631 bool arg2 ;
21632 PyObject * obj0 = 0 ;
21633 PyObject * obj1 = 0 ;
21634 char *kwnames[] = {
21635 (char *) "self",(char *) "forward", NULL
21636 };
21637
21638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21640 if (SWIG_arg_fail(1)) SWIG_fail;
21641 {
21642 arg2 = (bool)(SWIG_As_bool(obj1));
21643 if (SWIG_arg_fail(2)) SWIG_fail;
21644 }
21645 {
21646 PyThreadState* __tstate = wxPyBeginAllowThreads();
21647 (arg1)->SetDirection(arg2);
21648
21649 wxPyEndAllowThreads(__tstate);
21650 if (PyErr_Occurred()) SWIG_fail;
21651 }
21652 Py_INCREF(Py_None); resultobj = Py_None;
21653 return resultobj;
21654 fail:
21655 return NULL;
21656 }
21657
21658
21659 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21660 PyObject *resultobj;
21661 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21662 bool result;
21663 PyObject * obj0 = 0 ;
21664 char *kwnames[] = {
21665 (char *) "self", NULL
21666 };
21667
21668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21670 if (SWIG_arg_fail(1)) SWIG_fail;
21671 {
21672 PyThreadState* __tstate = wxPyBeginAllowThreads();
21673 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21674
21675 wxPyEndAllowThreads(__tstate);
21676 if (PyErr_Occurred()) SWIG_fail;
21677 }
21678 {
21679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21680 }
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21688 PyObject *resultobj;
21689 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21690 bool arg2 ;
21691 PyObject * obj0 = 0 ;
21692 PyObject * obj1 = 0 ;
21693 char *kwnames[] = {
21694 (char *) "self",(char *) "ischange", NULL
21695 };
21696
21697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21699 if (SWIG_arg_fail(1)) SWIG_fail;
21700 {
21701 arg2 = (bool)(SWIG_As_bool(obj1));
21702 if (SWIG_arg_fail(2)) SWIG_fail;
21703 }
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 (arg1)->SetWindowChange(arg2);
21707
21708 wxPyEndAllowThreads(__tstate);
21709 if (PyErr_Occurred()) SWIG_fail;
21710 }
21711 Py_INCREF(Py_None); resultobj = Py_None;
21712 return resultobj;
21713 fail:
21714 return NULL;
21715 }
21716
21717
21718 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21719 PyObject *resultobj;
21720 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21721 bool result;
21722 PyObject * obj0 = 0 ;
21723 char *kwnames[] = {
21724 (char *) "self", NULL
21725 };
21726
21727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21729 if (SWIG_arg_fail(1)) SWIG_fail;
21730 {
21731 PyThreadState* __tstate = wxPyBeginAllowThreads();
21732 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21733
21734 wxPyEndAllowThreads(__tstate);
21735 if (PyErr_Occurred()) SWIG_fail;
21736 }
21737 {
21738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21739 }
21740 return resultobj;
21741 fail:
21742 return NULL;
21743 }
21744
21745
21746 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21747 PyObject *resultobj;
21748 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21749 bool arg2 ;
21750 PyObject * obj0 = 0 ;
21751 PyObject * obj1 = 0 ;
21752 char *kwnames[] = {
21753 (char *) "self",(char *) "bIs", NULL
21754 };
21755
21756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21758 if (SWIG_arg_fail(1)) SWIG_fail;
21759 {
21760 arg2 = (bool)(SWIG_As_bool(obj1));
21761 if (SWIG_arg_fail(2)) SWIG_fail;
21762 }
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 (arg1)->SetFromTab(arg2);
21766
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 Py_INCREF(Py_None); resultobj = Py_None;
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21778 PyObject *resultobj;
21779 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21780 long arg2 ;
21781 PyObject * obj0 = 0 ;
21782 PyObject * obj1 = 0 ;
21783 char *kwnames[] = {
21784 (char *) "self",(char *) "flags", NULL
21785 };
21786
21787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21789 if (SWIG_arg_fail(1)) SWIG_fail;
21790 {
21791 arg2 = (long)(SWIG_As_long(obj1));
21792 if (SWIG_arg_fail(2)) SWIG_fail;
21793 }
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 (arg1)->SetFlags(arg2);
21797
21798 wxPyEndAllowThreads(__tstate);
21799 if (PyErr_Occurred()) SWIG_fail;
21800 }
21801 Py_INCREF(Py_None); resultobj = Py_None;
21802 return resultobj;
21803 fail:
21804 return NULL;
21805 }
21806
21807
21808 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21809 PyObject *resultobj;
21810 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21811 wxWindow *result;
21812 PyObject * obj0 = 0 ;
21813 char *kwnames[] = {
21814 (char *) "self", NULL
21815 };
21816
21817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21819 if (SWIG_arg_fail(1)) SWIG_fail;
21820 {
21821 PyThreadState* __tstate = wxPyBeginAllowThreads();
21822 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21823
21824 wxPyEndAllowThreads(__tstate);
21825 if (PyErr_Occurred()) SWIG_fail;
21826 }
21827 {
21828 resultobj = wxPyMake_wxObject(result, 0);
21829 }
21830 return resultobj;
21831 fail:
21832 return NULL;
21833 }
21834
21835
21836 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21837 PyObject *resultobj;
21838 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21839 wxWindow *arg2 = (wxWindow *) 0 ;
21840 PyObject * obj0 = 0 ;
21841 PyObject * obj1 = 0 ;
21842 char *kwnames[] = {
21843 (char *) "self",(char *) "win", NULL
21844 };
21845
21846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21848 if (SWIG_arg_fail(1)) SWIG_fail;
21849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21850 if (SWIG_arg_fail(2)) SWIG_fail;
21851 {
21852 PyThreadState* __tstate = wxPyBeginAllowThreads();
21853 (arg1)->SetCurrentFocus(arg2);
21854
21855 wxPyEndAllowThreads(__tstate);
21856 if (PyErr_Occurred()) SWIG_fail;
21857 }
21858 Py_INCREF(Py_None); resultobj = Py_None;
21859 return resultobj;
21860 fail:
21861 return NULL;
21862 }
21863
21864
21865 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21866 PyObject *obj;
21867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21868 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21869 Py_INCREF(obj);
21870 return Py_BuildValue((char *)"");
21871 }
21872 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21873 PyObject *resultobj;
21874 wxWindow *arg1 = (wxWindow *) NULL ;
21875 wxWindowCreateEvent *result;
21876 PyObject * obj0 = 0 ;
21877 char *kwnames[] = {
21878 (char *) "win", NULL
21879 };
21880
21881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21882 if (obj0) {
21883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21884 if (SWIG_arg_fail(1)) SWIG_fail;
21885 }
21886 {
21887 PyThreadState* __tstate = wxPyBeginAllowThreads();
21888 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21889
21890 wxPyEndAllowThreads(__tstate);
21891 if (PyErr_Occurred()) SWIG_fail;
21892 }
21893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21894 return resultobj;
21895 fail:
21896 return NULL;
21897 }
21898
21899
21900 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21901 PyObject *resultobj;
21902 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21903 wxWindow *result;
21904 PyObject * obj0 = 0 ;
21905 char *kwnames[] = {
21906 (char *) "self", NULL
21907 };
21908
21909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21911 if (SWIG_arg_fail(1)) SWIG_fail;
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21915
21916 wxPyEndAllowThreads(__tstate);
21917 if (PyErr_Occurred()) SWIG_fail;
21918 }
21919 {
21920 resultobj = wxPyMake_wxObject(result, 0);
21921 }
21922 return resultobj;
21923 fail:
21924 return NULL;
21925 }
21926
21927
21928 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21929 PyObject *obj;
21930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21931 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21932 Py_INCREF(obj);
21933 return Py_BuildValue((char *)"");
21934 }
21935 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21936 PyObject *resultobj;
21937 wxWindow *arg1 = (wxWindow *) NULL ;
21938 wxWindowDestroyEvent *result;
21939 PyObject * obj0 = 0 ;
21940 char *kwnames[] = {
21941 (char *) "win", NULL
21942 };
21943
21944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21945 if (obj0) {
21946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21947 if (SWIG_arg_fail(1)) SWIG_fail;
21948 }
21949 {
21950 PyThreadState* __tstate = wxPyBeginAllowThreads();
21951 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21952
21953 wxPyEndAllowThreads(__tstate);
21954 if (PyErr_Occurred()) SWIG_fail;
21955 }
21956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21957 return resultobj;
21958 fail:
21959 return NULL;
21960 }
21961
21962
21963 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21964 PyObject *resultobj;
21965 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21966 wxWindow *result;
21967 PyObject * obj0 = 0 ;
21968 char *kwnames[] = {
21969 (char *) "self", NULL
21970 };
21971
21972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21974 if (SWIG_arg_fail(1)) SWIG_fail;
21975 {
21976 PyThreadState* __tstate = wxPyBeginAllowThreads();
21977 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21978
21979 wxPyEndAllowThreads(__tstate);
21980 if (PyErr_Occurred()) SWIG_fail;
21981 }
21982 {
21983 resultobj = wxPyMake_wxObject(result, 0);
21984 }
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21992 PyObject *obj;
21993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21994 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21995 Py_INCREF(obj);
21996 return Py_BuildValue((char *)"");
21997 }
21998 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21999 PyObject *resultobj;
22000 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22001 int arg2 = (int) 0 ;
22002 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22003 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22004 wxContextMenuEvent *result;
22005 wxPoint temp3 ;
22006 PyObject * obj0 = 0 ;
22007 PyObject * obj1 = 0 ;
22008 PyObject * obj2 = 0 ;
22009 char *kwnames[] = {
22010 (char *) "type",(char *) "winid",(char *) "pt", NULL
22011 };
22012
22013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22014 if (obj0) {
22015 {
22016 arg1 = (wxEventType)(SWIG_As_int(obj0));
22017 if (SWIG_arg_fail(1)) SWIG_fail;
22018 }
22019 }
22020 if (obj1) {
22021 {
22022 arg2 = (int)(SWIG_As_int(obj1));
22023 if (SWIG_arg_fail(2)) SWIG_fail;
22024 }
22025 }
22026 if (obj2) {
22027 {
22028 arg3 = &temp3;
22029 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22030 }
22031 }
22032 {
22033 PyThreadState* __tstate = wxPyBeginAllowThreads();
22034 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22035
22036 wxPyEndAllowThreads(__tstate);
22037 if (PyErr_Occurred()) SWIG_fail;
22038 }
22039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj;
22048 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22049 wxPoint *result;
22050 PyObject * obj0 = 0 ;
22051 char *kwnames[] = {
22052 (char *) "self", NULL
22053 };
22054
22055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22057 if (SWIG_arg_fail(1)) SWIG_fail;
22058 {
22059 PyThreadState* __tstate = wxPyBeginAllowThreads();
22060 {
22061 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22062 result = (wxPoint *) &_result_ref;
22063 }
22064
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22069 return resultobj;
22070 fail:
22071 return NULL;
22072 }
22073
22074
22075 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22076 PyObject *resultobj;
22077 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22078 wxPoint *arg2 = 0 ;
22079 wxPoint temp2 ;
22080 PyObject * obj0 = 0 ;
22081 PyObject * obj1 = 0 ;
22082 char *kwnames[] = {
22083 (char *) "self",(char *) "pos", NULL
22084 };
22085
22086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22088 if (SWIG_arg_fail(1)) SWIG_fail;
22089 {
22090 arg2 = &temp2;
22091 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22092 }
22093 {
22094 PyThreadState* __tstate = wxPyBeginAllowThreads();
22095 (arg1)->SetPosition((wxPoint const &)*arg2);
22096
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 Py_INCREF(Py_None); resultobj = Py_None;
22101 return resultobj;
22102 fail:
22103 return NULL;
22104 }
22105
22106
22107 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22108 PyObject *obj;
22109 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22110 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22111 Py_INCREF(obj);
22112 return Py_BuildValue((char *)"");
22113 }
22114 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22115 PyObject *resultobj;
22116 wxIdleEvent *result;
22117 char *kwnames[] = {
22118 NULL
22119 };
22120
22121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22122 {
22123 PyThreadState* __tstate = wxPyBeginAllowThreads();
22124 result = (wxIdleEvent *)new wxIdleEvent();
22125
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22137 PyObject *resultobj;
22138 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22139 bool arg2 = (bool) true ;
22140 PyObject * obj0 = 0 ;
22141 PyObject * obj1 = 0 ;
22142 char *kwnames[] = {
22143 (char *) "self",(char *) "needMore", NULL
22144 };
22145
22146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22148 if (SWIG_arg_fail(1)) SWIG_fail;
22149 if (obj1) {
22150 {
22151 arg2 = (bool)(SWIG_As_bool(obj1));
22152 if (SWIG_arg_fail(2)) SWIG_fail;
22153 }
22154 }
22155 {
22156 PyThreadState* __tstate = wxPyBeginAllowThreads();
22157 (arg1)->RequestMore(arg2);
22158
22159 wxPyEndAllowThreads(__tstate);
22160 if (PyErr_Occurred()) SWIG_fail;
22161 }
22162 Py_INCREF(Py_None); resultobj = Py_None;
22163 return resultobj;
22164 fail:
22165 return NULL;
22166 }
22167
22168
22169 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22170 PyObject *resultobj;
22171 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22172 bool result;
22173 PyObject * obj0 = 0 ;
22174 char *kwnames[] = {
22175 (char *) "self", NULL
22176 };
22177
22178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22180 if (SWIG_arg_fail(1)) SWIG_fail;
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22184
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 {
22189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22190 }
22191 return resultobj;
22192 fail:
22193 return NULL;
22194 }
22195
22196
22197 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22198 PyObject *resultobj;
22199 wxIdleMode arg1 ;
22200 PyObject * obj0 = 0 ;
22201 char *kwnames[] = {
22202 (char *) "mode", NULL
22203 };
22204
22205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22206 {
22207 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22208 if (SWIG_arg_fail(1)) SWIG_fail;
22209 }
22210 {
22211 PyThreadState* __tstate = wxPyBeginAllowThreads();
22212 wxIdleEvent::SetMode((wxIdleMode )arg1);
22213
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 Py_INCREF(Py_None); resultobj = Py_None;
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22225 PyObject *resultobj;
22226 wxIdleMode result;
22227 char *kwnames[] = {
22228 NULL
22229 };
22230
22231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22232 {
22233 PyThreadState* __tstate = wxPyBeginAllowThreads();
22234 result = (wxIdleMode)wxIdleEvent::GetMode();
22235
22236 wxPyEndAllowThreads(__tstate);
22237 if (PyErr_Occurred()) SWIG_fail;
22238 }
22239 resultobj = SWIG_From_int((result));
22240 return resultobj;
22241 fail:
22242 return NULL;
22243 }
22244
22245
22246 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22247 PyObject *resultobj;
22248 wxWindow *arg1 = (wxWindow *) 0 ;
22249 bool result;
22250 PyObject * obj0 = 0 ;
22251 char *kwnames[] = {
22252 (char *) "win", NULL
22253 };
22254
22255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22257 if (SWIG_arg_fail(1)) SWIG_fail;
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 result = (bool)wxIdleEvent::CanSend(arg1);
22261
22262 wxPyEndAllowThreads(__tstate);
22263 if (PyErr_Occurred()) SWIG_fail;
22264 }
22265 {
22266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22267 }
22268 return resultobj;
22269 fail:
22270 return NULL;
22271 }
22272
22273
22274 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22275 PyObject *obj;
22276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22277 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22278 Py_INCREF(obj);
22279 return Py_BuildValue((char *)"");
22280 }
22281 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22282 PyObject *resultobj;
22283 int arg1 = (int) 0 ;
22284 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22285 wxPyEvent *result;
22286 PyObject * obj0 = 0 ;
22287 PyObject * obj1 = 0 ;
22288 char *kwnames[] = {
22289 (char *) "winid",(char *) "eventType", NULL
22290 };
22291
22292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22293 if (obj0) {
22294 {
22295 arg1 = (int)(SWIG_As_int(obj0));
22296 if (SWIG_arg_fail(1)) SWIG_fail;
22297 }
22298 }
22299 if (obj1) {
22300 {
22301 arg2 = (wxEventType)(SWIG_As_int(obj1));
22302 if (SWIG_arg_fail(2)) SWIG_fail;
22303 }
22304 }
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22308
22309 wxPyEndAllowThreads(__tstate);
22310 if (PyErr_Occurred()) SWIG_fail;
22311 }
22312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22313 return resultobj;
22314 fail:
22315 return NULL;
22316 }
22317
22318
22319 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22320 PyObject *resultobj;
22321 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22322 PyObject * obj0 = 0 ;
22323 char *kwnames[] = {
22324 (char *) "self", NULL
22325 };
22326
22327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22329 if (SWIG_arg_fail(1)) SWIG_fail;
22330 {
22331 PyThreadState* __tstate = wxPyBeginAllowThreads();
22332 delete arg1;
22333
22334 wxPyEndAllowThreads(__tstate);
22335 if (PyErr_Occurred()) SWIG_fail;
22336 }
22337 Py_INCREF(Py_None); resultobj = Py_None;
22338 return resultobj;
22339 fail:
22340 return NULL;
22341 }
22342
22343
22344 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22345 PyObject *resultobj;
22346 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22347 PyObject *arg2 = (PyObject *) 0 ;
22348 PyObject * obj0 = 0 ;
22349 PyObject * obj1 = 0 ;
22350 char *kwnames[] = {
22351 (char *) "self",(char *) "self", NULL
22352 };
22353
22354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22356 if (SWIG_arg_fail(1)) SWIG_fail;
22357 arg2 = obj1;
22358 {
22359 PyThreadState* __tstate = wxPyBeginAllowThreads();
22360 (arg1)->SetSelf(arg2);
22361
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 Py_INCREF(Py_None); resultobj = Py_None;
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22373 PyObject *resultobj;
22374 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22375 PyObject *result;
22376 PyObject * obj0 = 0 ;
22377 char *kwnames[] = {
22378 (char *) "self", NULL
22379 };
22380
22381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22383 if (SWIG_arg_fail(1)) SWIG_fail;
22384 {
22385 PyThreadState* __tstate = wxPyBeginAllowThreads();
22386 result = (PyObject *)(arg1)->GetSelf();
22387
22388 wxPyEndAllowThreads(__tstate);
22389 if (PyErr_Occurred()) SWIG_fail;
22390 }
22391 resultobj = result;
22392 return resultobj;
22393 fail:
22394 return NULL;
22395 }
22396
22397
22398 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22399 PyObject *obj;
22400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22401 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22402 Py_INCREF(obj);
22403 return Py_BuildValue((char *)"");
22404 }
22405 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22406 PyObject *resultobj;
22407 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22408 int arg2 = (int) 0 ;
22409 wxPyCommandEvent *result;
22410 PyObject * obj0 = 0 ;
22411 PyObject * obj1 = 0 ;
22412 char *kwnames[] = {
22413 (char *) "eventType",(char *) "id", NULL
22414 };
22415
22416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22417 if (obj0) {
22418 {
22419 arg1 = (wxEventType)(SWIG_As_int(obj0));
22420 if (SWIG_arg_fail(1)) SWIG_fail;
22421 }
22422 }
22423 if (obj1) {
22424 {
22425 arg2 = (int)(SWIG_As_int(obj1));
22426 if (SWIG_arg_fail(2)) SWIG_fail;
22427 }
22428 }
22429 {
22430 PyThreadState* __tstate = wxPyBeginAllowThreads();
22431 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22432
22433 wxPyEndAllowThreads(__tstate);
22434 if (PyErr_Occurred()) SWIG_fail;
22435 }
22436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22437 return resultobj;
22438 fail:
22439 return NULL;
22440 }
22441
22442
22443 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22444 PyObject *resultobj;
22445 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22446 PyObject * obj0 = 0 ;
22447 char *kwnames[] = {
22448 (char *) "self", NULL
22449 };
22450
22451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22453 if (SWIG_arg_fail(1)) SWIG_fail;
22454 {
22455 PyThreadState* __tstate = wxPyBeginAllowThreads();
22456 delete arg1;
22457
22458 wxPyEndAllowThreads(__tstate);
22459 if (PyErr_Occurred()) SWIG_fail;
22460 }
22461 Py_INCREF(Py_None); resultobj = Py_None;
22462 return resultobj;
22463 fail:
22464 return NULL;
22465 }
22466
22467
22468 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22469 PyObject *resultobj;
22470 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22471 PyObject *arg2 = (PyObject *) 0 ;
22472 PyObject * obj0 = 0 ;
22473 PyObject * obj1 = 0 ;
22474 char *kwnames[] = {
22475 (char *) "self",(char *) "self", NULL
22476 };
22477
22478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22480 if (SWIG_arg_fail(1)) SWIG_fail;
22481 arg2 = obj1;
22482 {
22483 PyThreadState* __tstate = wxPyBeginAllowThreads();
22484 (arg1)->SetSelf(arg2);
22485
22486 wxPyEndAllowThreads(__tstate);
22487 if (PyErr_Occurred()) SWIG_fail;
22488 }
22489 Py_INCREF(Py_None); resultobj = Py_None;
22490 return resultobj;
22491 fail:
22492 return NULL;
22493 }
22494
22495
22496 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22497 PyObject *resultobj;
22498 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22499 PyObject *result;
22500 PyObject * obj0 = 0 ;
22501 char *kwnames[] = {
22502 (char *) "self", NULL
22503 };
22504
22505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
22506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22507 if (SWIG_arg_fail(1)) SWIG_fail;
22508 {
22509 PyThreadState* __tstate = wxPyBeginAllowThreads();
22510 result = (PyObject *)(arg1)->GetSelf();
22511
22512 wxPyEndAllowThreads(__tstate);
22513 if (PyErr_Occurred()) SWIG_fail;
22514 }
22515 resultobj = result;
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22523 PyObject *obj;
22524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22525 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22526 Py_INCREF(obj);
22527 return Py_BuildValue((char *)"");
22528 }
22529 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22530 PyObject *resultobj;
22531 wxWindow *arg1 = (wxWindow *) 0 ;
22532 wxDateTime *arg2 = 0 ;
22533 wxEventType arg3 ;
22534 wxDateEvent *result;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537 PyObject * obj2 = 0 ;
22538 char *kwnames[] = {
22539 (char *) "win",(char *) "dt",(char *) "type", NULL
22540 };
22541
22542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22544 if (SWIG_arg_fail(1)) SWIG_fail;
22545 {
22546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22547 if (SWIG_arg_fail(2)) SWIG_fail;
22548 if (arg2 == NULL) {
22549 SWIG_null_ref("wxDateTime");
22550 }
22551 if (SWIG_arg_fail(2)) SWIG_fail;
22552 }
22553 {
22554 arg3 = (wxEventType)(SWIG_As_int(obj2));
22555 if (SWIG_arg_fail(3)) SWIG_fail;
22556 }
22557 {
22558 PyThreadState* __tstate = wxPyBeginAllowThreads();
22559 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22560
22561 wxPyEndAllowThreads(__tstate);
22562 if (PyErr_Occurred()) SWIG_fail;
22563 }
22564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22565 return resultobj;
22566 fail:
22567 return NULL;
22568 }
22569
22570
22571 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22572 PyObject *resultobj;
22573 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22574 wxDateTime *result;
22575 PyObject * obj0 = 0 ;
22576 char *kwnames[] = {
22577 (char *) "self", NULL
22578 };
22579
22580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22582 if (SWIG_arg_fail(1)) SWIG_fail;
22583 {
22584 PyThreadState* __tstate = wxPyBeginAllowThreads();
22585 {
22586 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22587 result = (wxDateTime *) &_result_ref;
22588 }
22589
22590 wxPyEndAllowThreads(__tstate);
22591 if (PyErr_Occurred()) SWIG_fail;
22592 }
22593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22594 return resultobj;
22595 fail:
22596 return NULL;
22597 }
22598
22599
22600 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22601 PyObject *resultobj;
22602 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22603 wxDateTime *arg2 = 0 ;
22604 PyObject * obj0 = 0 ;
22605 PyObject * obj1 = 0 ;
22606 char *kwnames[] = {
22607 (char *) "self",(char *) "date", NULL
22608 };
22609
22610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22612 if (SWIG_arg_fail(1)) SWIG_fail;
22613 {
22614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22615 if (SWIG_arg_fail(2)) SWIG_fail;
22616 if (arg2 == NULL) {
22617 SWIG_null_ref("wxDateTime");
22618 }
22619 if (SWIG_arg_fail(2)) SWIG_fail;
22620 }
22621 {
22622 PyThreadState* __tstate = wxPyBeginAllowThreads();
22623 (arg1)->SetDate((wxDateTime const &)*arg2);
22624
22625 wxPyEndAllowThreads(__tstate);
22626 if (PyErr_Occurred()) SWIG_fail;
22627 }
22628 Py_INCREF(Py_None); resultobj = Py_None;
22629 return resultobj;
22630 fail:
22631 return NULL;
22632 }
22633
22634
22635 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22636 PyObject *obj;
22637 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22638 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22639 Py_INCREF(obj);
22640 return Py_BuildValue((char *)"");
22641 }
22642 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22643 PyObject *resultobj;
22644 wxPyApp *result;
22645 char *kwnames[] = {
22646 NULL
22647 };
22648
22649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22650 {
22651 PyThreadState* __tstate = wxPyBeginAllowThreads();
22652 result = (wxPyApp *)new_wxPyApp();
22653
22654 wxPyEndAllowThreads(__tstate);
22655 if (PyErr_Occurred()) SWIG_fail;
22656 }
22657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22658 return resultobj;
22659 fail:
22660 return NULL;
22661 }
22662
22663
22664 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22665 PyObject *resultobj;
22666 wxPyApp *arg1 = (wxPyApp *) 0 ;
22667 PyObject * obj0 = 0 ;
22668 char *kwnames[] = {
22669 (char *) "self", NULL
22670 };
22671
22672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22674 if (SWIG_arg_fail(1)) SWIG_fail;
22675 {
22676 PyThreadState* __tstate = wxPyBeginAllowThreads();
22677 delete arg1;
22678
22679 wxPyEndAllowThreads(__tstate);
22680 if (PyErr_Occurred()) SWIG_fail;
22681 }
22682 Py_INCREF(Py_None); resultobj = Py_None;
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22690 PyObject *resultobj;
22691 wxPyApp *arg1 = (wxPyApp *) 0 ;
22692 PyObject *arg2 = (PyObject *) 0 ;
22693 PyObject *arg3 = (PyObject *) 0 ;
22694 bool arg4 ;
22695 PyObject * obj0 = 0 ;
22696 PyObject * obj1 = 0 ;
22697 PyObject * obj2 = 0 ;
22698 PyObject * obj3 = 0 ;
22699 char *kwnames[] = {
22700 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22701 };
22702
22703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22705 if (SWIG_arg_fail(1)) SWIG_fail;
22706 arg2 = obj1;
22707 arg3 = obj2;
22708 {
22709 arg4 = (bool)(SWIG_As_bool(obj3));
22710 if (SWIG_arg_fail(4)) SWIG_fail;
22711 }
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22715
22716 wxPyEndAllowThreads(__tstate);
22717 if (PyErr_Occurred()) SWIG_fail;
22718 }
22719 Py_INCREF(Py_None); resultobj = Py_None;
22720 return resultobj;
22721 fail:
22722 return NULL;
22723 }
22724
22725
22726 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22727 PyObject *resultobj;
22728 wxPyApp *arg1 = (wxPyApp *) 0 ;
22729 wxString result;
22730 PyObject * obj0 = 0 ;
22731 char *kwnames[] = {
22732 (char *) "self", NULL
22733 };
22734
22735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22737 if (SWIG_arg_fail(1)) SWIG_fail;
22738 {
22739 PyThreadState* __tstate = wxPyBeginAllowThreads();
22740 result = ((wxPyApp const *)arg1)->GetAppName();
22741
22742 wxPyEndAllowThreads(__tstate);
22743 if (PyErr_Occurred()) SWIG_fail;
22744 }
22745 {
22746 #if wxUSE_UNICODE
22747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22748 #else
22749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22750 #endif
22751 }
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22759 PyObject *resultobj;
22760 wxPyApp *arg1 = (wxPyApp *) 0 ;
22761 wxString *arg2 = 0 ;
22762 bool temp2 = false ;
22763 PyObject * obj0 = 0 ;
22764 PyObject * obj1 = 0 ;
22765 char *kwnames[] = {
22766 (char *) "self",(char *) "name", NULL
22767 };
22768
22769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22771 if (SWIG_arg_fail(1)) SWIG_fail;
22772 {
22773 arg2 = wxString_in_helper(obj1);
22774 if (arg2 == NULL) SWIG_fail;
22775 temp2 = true;
22776 }
22777 {
22778 PyThreadState* __tstate = wxPyBeginAllowThreads();
22779 (arg1)->SetAppName((wxString const &)*arg2);
22780
22781 wxPyEndAllowThreads(__tstate);
22782 if (PyErr_Occurred()) SWIG_fail;
22783 }
22784 Py_INCREF(Py_None); resultobj = Py_None;
22785 {
22786 if (temp2)
22787 delete arg2;
22788 }
22789 return resultobj;
22790 fail:
22791 {
22792 if (temp2)
22793 delete arg2;
22794 }
22795 return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22800 PyObject *resultobj;
22801 wxPyApp *arg1 = (wxPyApp *) 0 ;
22802 wxString result;
22803 PyObject * obj0 = 0 ;
22804 char *kwnames[] = {
22805 (char *) "self", NULL
22806 };
22807
22808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22810 if (SWIG_arg_fail(1)) SWIG_fail;
22811 {
22812 PyThreadState* __tstate = wxPyBeginAllowThreads();
22813 result = ((wxPyApp const *)arg1)->GetClassName();
22814
22815 wxPyEndAllowThreads(__tstate);
22816 if (PyErr_Occurred()) SWIG_fail;
22817 }
22818 {
22819 #if wxUSE_UNICODE
22820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22821 #else
22822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22823 #endif
22824 }
22825 return resultobj;
22826 fail:
22827 return NULL;
22828 }
22829
22830
22831 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22832 PyObject *resultobj;
22833 wxPyApp *arg1 = (wxPyApp *) 0 ;
22834 wxString *arg2 = 0 ;
22835 bool temp2 = false ;
22836 PyObject * obj0 = 0 ;
22837 PyObject * obj1 = 0 ;
22838 char *kwnames[] = {
22839 (char *) "self",(char *) "name", NULL
22840 };
22841
22842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22844 if (SWIG_arg_fail(1)) SWIG_fail;
22845 {
22846 arg2 = wxString_in_helper(obj1);
22847 if (arg2 == NULL) SWIG_fail;
22848 temp2 = true;
22849 }
22850 {
22851 PyThreadState* __tstate = wxPyBeginAllowThreads();
22852 (arg1)->SetClassName((wxString const &)*arg2);
22853
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 Py_INCREF(Py_None); resultobj = Py_None;
22858 {
22859 if (temp2)
22860 delete arg2;
22861 }
22862 return resultobj;
22863 fail:
22864 {
22865 if (temp2)
22866 delete arg2;
22867 }
22868 return NULL;
22869 }
22870
22871
22872 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj;
22874 wxPyApp *arg1 = (wxPyApp *) 0 ;
22875 wxString *result;
22876 PyObject * obj0 = 0 ;
22877 char *kwnames[] = {
22878 (char *) "self", NULL
22879 };
22880
22881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22883 if (SWIG_arg_fail(1)) SWIG_fail;
22884 {
22885 PyThreadState* __tstate = wxPyBeginAllowThreads();
22886 {
22887 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22888 result = (wxString *) &_result_ref;
22889 }
22890
22891 wxPyEndAllowThreads(__tstate);
22892 if (PyErr_Occurred()) SWIG_fail;
22893 }
22894 {
22895 #if wxUSE_UNICODE
22896 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22897 #else
22898 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22899 #endif
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22908 PyObject *resultobj;
22909 wxPyApp *arg1 = (wxPyApp *) 0 ;
22910 wxString *arg2 = 0 ;
22911 bool temp2 = false ;
22912 PyObject * obj0 = 0 ;
22913 PyObject * obj1 = 0 ;
22914 char *kwnames[] = {
22915 (char *) "self",(char *) "name", NULL
22916 };
22917
22918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22920 if (SWIG_arg_fail(1)) SWIG_fail;
22921 {
22922 arg2 = wxString_in_helper(obj1);
22923 if (arg2 == NULL) SWIG_fail;
22924 temp2 = true;
22925 }
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 (arg1)->SetVendorName((wxString const &)*arg2);
22929
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 Py_INCREF(Py_None); resultobj = Py_None;
22934 {
22935 if (temp2)
22936 delete arg2;
22937 }
22938 return resultobj;
22939 fail:
22940 {
22941 if (temp2)
22942 delete arg2;
22943 }
22944 return NULL;
22945 }
22946
22947
22948 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22949 PyObject *resultobj;
22950 wxPyApp *arg1 = (wxPyApp *) 0 ;
22951 wxAppTraits *result;
22952 PyObject * obj0 = 0 ;
22953 char *kwnames[] = {
22954 (char *) "self", NULL
22955 };
22956
22957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22959 if (SWIG_arg_fail(1)) SWIG_fail;
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 result = (wxAppTraits *)(arg1)->GetTraits();
22963
22964 wxPyEndAllowThreads(__tstate);
22965 if (PyErr_Occurred()) SWIG_fail;
22966 }
22967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22968 return resultobj;
22969 fail:
22970 return NULL;
22971 }
22972
22973
22974 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22975 PyObject *resultobj;
22976 wxPyApp *arg1 = (wxPyApp *) 0 ;
22977 PyObject * obj0 = 0 ;
22978 char *kwnames[] = {
22979 (char *) "self", NULL
22980 };
22981
22982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22984 if (SWIG_arg_fail(1)) SWIG_fail;
22985 {
22986 PyThreadState* __tstate = wxPyBeginAllowThreads();
22987 (arg1)->ProcessPendingEvents();
22988
22989 wxPyEndAllowThreads(__tstate);
22990 if (PyErr_Occurred()) SWIG_fail;
22991 }
22992 Py_INCREF(Py_None); resultobj = Py_None;
22993 return resultobj;
22994 fail:
22995 return NULL;
22996 }
22997
22998
22999 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23000 PyObject *resultobj;
23001 wxPyApp *arg1 = (wxPyApp *) 0 ;
23002 bool arg2 = (bool) false ;
23003 bool result;
23004 PyObject * obj0 = 0 ;
23005 PyObject * obj1 = 0 ;
23006 char *kwnames[] = {
23007 (char *) "self",(char *) "onlyIfNeeded", NULL
23008 };
23009
23010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23012 if (SWIG_arg_fail(1)) SWIG_fail;
23013 if (obj1) {
23014 {
23015 arg2 = (bool)(SWIG_As_bool(obj1));
23016 if (SWIG_arg_fail(2)) SWIG_fail;
23017 }
23018 }
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 result = (bool)(arg1)->Yield(arg2);
23022
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 {
23027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23028 }
23029 return resultobj;
23030 fail:
23031 return NULL;
23032 }
23033
23034
23035 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23036 PyObject *resultobj;
23037 wxPyApp *arg1 = (wxPyApp *) 0 ;
23038 PyObject * obj0 = 0 ;
23039 char *kwnames[] = {
23040 (char *) "self", NULL
23041 };
23042
23043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23045 if (SWIG_arg_fail(1)) SWIG_fail;
23046 {
23047 PyThreadState* __tstate = wxPyBeginAllowThreads();
23048 (arg1)->WakeUpIdle();
23049
23050 wxPyEndAllowThreads(__tstate);
23051 if (PyErr_Occurred()) SWIG_fail;
23052 }
23053 Py_INCREF(Py_None); resultobj = Py_None;
23054 return resultobj;
23055 fail:
23056 return NULL;
23057 }
23058
23059
23060 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23061 PyObject *resultobj;
23062 bool result;
23063 char *kwnames[] = {
23064 NULL
23065 };
23066
23067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 result = (bool)wxPyApp::IsMainLoopRunning();
23071
23072 wxPyEndAllowThreads(__tstate);
23073 if (PyErr_Occurred()) SWIG_fail;
23074 }
23075 {
23076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23077 }
23078 return resultobj;
23079 fail:
23080 return NULL;
23081 }
23082
23083
23084 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23085 PyObject *resultobj;
23086 wxPyApp *arg1 = (wxPyApp *) 0 ;
23087 int result;
23088 PyObject * obj0 = 0 ;
23089 char *kwnames[] = {
23090 (char *) "self", NULL
23091 };
23092
23093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23095 if (SWIG_arg_fail(1)) SWIG_fail;
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = (int)(arg1)->MainLoop();
23099
23100 wxPyEndAllowThreads(__tstate);
23101 if (PyErr_Occurred()) SWIG_fail;
23102 }
23103 {
23104 resultobj = SWIG_From_int((int)(result));
23105 }
23106 return resultobj;
23107 fail:
23108 return NULL;
23109 }
23110
23111
23112 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23113 PyObject *resultobj;
23114 wxPyApp *arg1 = (wxPyApp *) 0 ;
23115 PyObject * obj0 = 0 ;
23116 char *kwnames[] = {
23117 (char *) "self", NULL
23118 };
23119
23120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23122 if (SWIG_arg_fail(1)) SWIG_fail;
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 (arg1)->Exit();
23126
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 Py_INCREF(Py_None); resultobj = Py_None;
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23138 PyObject *resultobj;
23139 wxPyApp *arg1 = (wxPyApp *) 0 ;
23140 PyObject * obj0 = 0 ;
23141 char *kwnames[] = {
23142 (char *) "self", NULL
23143 };
23144
23145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23147 if (SWIG_arg_fail(1)) SWIG_fail;
23148 {
23149 PyThreadState* __tstate = wxPyBeginAllowThreads();
23150 (arg1)->ExitMainLoop();
23151
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 Py_INCREF(Py_None); resultobj = Py_None;
23156 return resultobj;
23157 fail:
23158 return NULL;
23159 }
23160
23161
23162 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23163 PyObject *resultobj;
23164 wxPyApp *arg1 = (wxPyApp *) 0 ;
23165 bool result;
23166 PyObject * obj0 = 0 ;
23167 char *kwnames[] = {
23168 (char *) "self", NULL
23169 };
23170
23171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23173 if (SWIG_arg_fail(1)) SWIG_fail;
23174 {
23175 PyThreadState* __tstate = wxPyBeginAllowThreads();
23176 result = (bool)(arg1)->Pending();
23177
23178 wxPyEndAllowThreads(__tstate);
23179 if (PyErr_Occurred()) SWIG_fail;
23180 }
23181 {
23182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23183 }
23184 return resultobj;
23185 fail:
23186 return NULL;
23187 }
23188
23189
23190 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23191 PyObject *resultobj;
23192 wxPyApp *arg1 = (wxPyApp *) 0 ;
23193 bool result;
23194 PyObject * obj0 = 0 ;
23195 char *kwnames[] = {
23196 (char *) "self", NULL
23197 };
23198
23199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23201 if (SWIG_arg_fail(1)) SWIG_fail;
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = (bool)(arg1)->Dispatch();
23205
23206 wxPyEndAllowThreads(__tstate);
23207 if (PyErr_Occurred()) SWIG_fail;
23208 }
23209 {
23210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23211 }
23212 return resultobj;
23213 fail:
23214 return NULL;
23215 }
23216
23217
23218 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23219 PyObject *resultobj;
23220 wxPyApp *arg1 = (wxPyApp *) 0 ;
23221 bool result;
23222 PyObject * obj0 = 0 ;
23223 char *kwnames[] = {
23224 (char *) "self", NULL
23225 };
23226
23227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23229 if (SWIG_arg_fail(1)) SWIG_fail;
23230 {
23231 PyThreadState* __tstate = wxPyBeginAllowThreads();
23232 result = (bool)(arg1)->ProcessIdle();
23233
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 {
23238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23239 }
23240 return resultobj;
23241 fail:
23242 return NULL;
23243 }
23244
23245
23246 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23247 PyObject *resultobj;
23248 wxPyApp *arg1 = (wxPyApp *) 0 ;
23249 wxWindow *arg2 = (wxWindow *) 0 ;
23250 wxIdleEvent *arg3 = 0 ;
23251 bool result;
23252 PyObject * obj0 = 0 ;
23253 PyObject * obj1 = 0 ;
23254 PyObject * obj2 = 0 ;
23255 char *kwnames[] = {
23256 (char *) "self",(char *) "win",(char *) "event", NULL
23257 };
23258
23259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23261 if (SWIG_arg_fail(1)) SWIG_fail;
23262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23263 if (SWIG_arg_fail(2)) SWIG_fail;
23264 {
23265 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23266 if (SWIG_arg_fail(3)) SWIG_fail;
23267 if (arg3 == NULL) {
23268 SWIG_null_ref("wxIdleEvent");
23269 }
23270 if (SWIG_arg_fail(3)) SWIG_fail;
23271 }
23272 {
23273 PyThreadState* __tstate = wxPyBeginAllowThreads();
23274 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23275
23276 wxPyEndAllowThreads(__tstate);
23277 if (PyErr_Occurred()) SWIG_fail;
23278 }
23279 {
23280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23281 }
23282 return resultobj;
23283 fail:
23284 return NULL;
23285 }
23286
23287
23288 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23289 PyObject *resultobj;
23290 wxPyApp *arg1 = (wxPyApp *) 0 ;
23291 bool result;
23292 PyObject * obj0 = 0 ;
23293 char *kwnames[] = {
23294 (char *) "self", NULL
23295 };
23296
23297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23299 if (SWIG_arg_fail(1)) SWIG_fail;
23300 {
23301 PyThreadState* __tstate = wxPyBeginAllowThreads();
23302 result = (bool)((wxPyApp const *)arg1)->IsActive();
23303
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 {
23308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23309 }
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23317 PyObject *resultobj;
23318 wxPyApp *arg1 = (wxPyApp *) 0 ;
23319 wxWindow *arg2 = (wxWindow *) 0 ;
23320 PyObject * obj0 = 0 ;
23321 PyObject * obj1 = 0 ;
23322 char *kwnames[] = {
23323 (char *) "self",(char *) "win", NULL
23324 };
23325
23326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23328 if (SWIG_arg_fail(1)) SWIG_fail;
23329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23330 if (SWIG_arg_fail(2)) SWIG_fail;
23331 {
23332 PyThreadState* __tstate = wxPyBeginAllowThreads();
23333 (arg1)->SetTopWindow(arg2);
23334
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 Py_INCREF(Py_None); resultobj = Py_None;
23339 return resultobj;
23340 fail:
23341 return NULL;
23342 }
23343
23344
23345 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23346 PyObject *resultobj;
23347 wxPyApp *arg1 = (wxPyApp *) 0 ;
23348 wxWindow *result;
23349 PyObject * obj0 = 0 ;
23350 char *kwnames[] = {
23351 (char *) "self", NULL
23352 };
23353
23354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23356 if (SWIG_arg_fail(1)) SWIG_fail;
23357 {
23358 PyThreadState* __tstate = wxPyBeginAllowThreads();
23359 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23360
23361 wxPyEndAllowThreads(__tstate);
23362 if (PyErr_Occurred()) SWIG_fail;
23363 }
23364 {
23365 resultobj = wxPyMake_wxObject(result, 0);
23366 }
23367 return resultobj;
23368 fail:
23369 return NULL;
23370 }
23371
23372
23373 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23374 PyObject *resultobj;
23375 wxPyApp *arg1 = (wxPyApp *) 0 ;
23376 bool arg2 ;
23377 PyObject * obj0 = 0 ;
23378 PyObject * obj1 = 0 ;
23379 char *kwnames[] = {
23380 (char *) "self",(char *) "flag", NULL
23381 };
23382
23383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23385 if (SWIG_arg_fail(1)) SWIG_fail;
23386 {
23387 arg2 = (bool)(SWIG_As_bool(obj1));
23388 if (SWIG_arg_fail(2)) SWIG_fail;
23389 }
23390 {
23391 PyThreadState* __tstate = wxPyBeginAllowThreads();
23392 (arg1)->SetExitOnFrameDelete(arg2);
23393
23394 wxPyEndAllowThreads(__tstate);
23395 if (PyErr_Occurred()) SWIG_fail;
23396 }
23397 Py_INCREF(Py_None); resultobj = Py_None;
23398 return resultobj;
23399 fail:
23400 return NULL;
23401 }
23402
23403
23404 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23405 PyObject *resultobj;
23406 wxPyApp *arg1 = (wxPyApp *) 0 ;
23407 bool result;
23408 PyObject * obj0 = 0 ;
23409 char *kwnames[] = {
23410 (char *) "self", NULL
23411 };
23412
23413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23415 if (SWIG_arg_fail(1)) SWIG_fail;
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23419
23420 wxPyEndAllowThreads(__tstate);
23421 if (PyErr_Occurred()) SWIG_fail;
23422 }
23423 {
23424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23425 }
23426 return resultobj;
23427 fail:
23428 return NULL;
23429 }
23430
23431
23432 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23433 PyObject *resultobj;
23434 wxPyApp *arg1 = (wxPyApp *) 0 ;
23435 bool arg2 ;
23436 PyObject * obj0 = 0 ;
23437 PyObject * obj1 = 0 ;
23438 char *kwnames[] = {
23439 (char *) "self",(char *) "flag", NULL
23440 };
23441
23442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23444 if (SWIG_arg_fail(1)) SWIG_fail;
23445 {
23446 arg2 = (bool)(SWIG_As_bool(obj1));
23447 if (SWIG_arg_fail(2)) SWIG_fail;
23448 }
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 (arg1)->SetUseBestVisual(arg2);
23452
23453 wxPyEndAllowThreads(__tstate);
23454 if (PyErr_Occurred()) SWIG_fail;
23455 }
23456 Py_INCREF(Py_None); resultobj = Py_None;
23457 return resultobj;
23458 fail:
23459 return NULL;
23460 }
23461
23462
23463 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23464 PyObject *resultobj;
23465 wxPyApp *arg1 = (wxPyApp *) 0 ;
23466 bool result;
23467 PyObject * obj0 = 0 ;
23468 char *kwnames[] = {
23469 (char *) "self", NULL
23470 };
23471
23472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23474 if (SWIG_arg_fail(1)) SWIG_fail;
23475 {
23476 PyThreadState* __tstate = wxPyBeginAllowThreads();
23477 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23478
23479 wxPyEndAllowThreads(__tstate);
23480 if (PyErr_Occurred()) SWIG_fail;
23481 }
23482 {
23483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23484 }
23485 return resultobj;
23486 fail:
23487 return NULL;
23488 }
23489
23490
23491 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23492 PyObject *resultobj;
23493 wxPyApp *arg1 = (wxPyApp *) 0 ;
23494 int arg2 ;
23495 PyObject * obj0 = 0 ;
23496 PyObject * obj1 = 0 ;
23497 char *kwnames[] = {
23498 (char *) "self",(char *) "mode", NULL
23499 };
23500
23501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23503 if (SWIG_arg_fail(1)) SWIG_fail;
23504 {
23505 arg2 = (int)(SWIG_As_int(obj1));
23506 if (SWIG_arg_fail(2)) SWIG_fail;
23507 }
23508 {
23509 PyThreadState* __tstate = wxPyBeginAllowThreads();
23510 (arg1)->SetPrintMode(arg2);
23511
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 Py_INCREF(Py_None); resultobj = Py_None;
23516 return resultobj;
23517 fail:
23518 return NULL;
23519 }
23520
23521
23522 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23523 PyObject *resultobj;
23524 wxPyApp *arg1 = (wxPyApp *) 0 ;
23525 int result;
23526 PyObject * obj0 = 0 ;
23527 char *kwnames[] = {
23528 (char *) "self", NULL
23529 };
23530
23531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23533 if (SWIG_arg_fail(1)) SWIG_fail;
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23537
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 {
23542 resultobj = SWIG_From_int((int)(result));
23543 }
23544 return resultobj;
23545 fail:
23546 return NULL;
23547 }
23548
23549
23550 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23551 PyObject *resultobj;
23552 wxPyApp *arg1 = (wxPyApp *) 0 ;
23553 int arg2 ;
23554 PyObject * obj0 = 0 ;
23555 PyObject * obj1 = 0 ;
23556 char *kwnames[] = {
23557 (char *) "self",(char *) "mode", NULL
23558 };
23559
23560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23562 if (SWIG_arg_fail(1)) SWIG_fail;
23563 {
23564 arg2 = (int)(SWIG_As_int(obj1));
23565 if (SWIG_arg_fail(2)) SWIG_fail;
23566 }
23567 {
23568 PyThreadState* __tstate = wxPyBeginAllowThreads();
23569 (arg1)->SetAssertMode(arg2);
23570
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 Py_INCREF(Py_None); resultobj = Py_None;
23575 return resultobj;
23576 fail:
23577 return NULL;
23578 }
23579
23580
23581 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23582 PyObject *resultobj;
23583 wxPyApp *arg1 = (wxPyApp *) 0 ;
23584 int result;
23585 PyObject * obj0 = 0 ;
23586 char *kwnames[] = {
23587 (char *) "self", NULL
23588 };
23589
23590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23592 if (SWIG_arg_fail(1)) SWIG_fail;
23593 {
23594 PyThreadState* __tstate = wxPyBeginAllowThreads();
23595 result = (int)(arg1)->GetAssertMode();
23596
23597 wxPyEndAllowThreads(__tstate);
23598 if (PyErr_Occurred()) SWIG_fail;
23599 }
23600 {
23601 resultobj = SWIG_From_int((int)(result));
23602 }
23603 return resultobj;
23604 fail:
23605 return NULL;
23606 }
23607
23608
23609 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23610 PyObject *resultobj;
23611 bool result;
23612 char *kwnames[] = {
23613 NULL
23614 };
23615
23616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23620
23621 wxPyEndAllowThreads(__tstate);
23622 if (PyErr_Occurred()) SWIG_fail;
23623 }
23624 {
23625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23626 }
23627 return resultobj;
23628 fail:
23629 return NULL;
23630 }
23631
23632
23633 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23634 PyObject *resultobj;
23635 long result;
23636 char *kwnames[] = {
23637 NULL
23638 };
23639
23640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23641 {
23642 PyThreadState* __tstate = wxPyBeginAllowThreads();
23643 result = (long)wxPyApp::GetMacAboutMenuItemId();
23644
23645 wxPyEndAllowThreads(__tstate);
23646 if (PyErr_Occurred()) SWIG_fail;
23647 }
23648 {
23649 resultobj = SWIG_From_long((long)(result));
23650 }
23651 return resultobj;
23652 fail:
23653 return NULL;
23654 }
23655
23656
23657 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23658 PyObject *resultobj;
23659 long result;
23660 char *kwnames[] = {
23661 NULL
23662 };
23663
23664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23665 {
23666 PyThreadState* __tstate = wxPyBeginAllowThreads();
23667 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23668
23669 wxPyEndAllowThreads(__tstate);
23670 if (PyErr_Occurred()) SWIG_fail;
23671 }
23672 {
23673 resultobj = SWIG_From_long((long)(result));
23674 }
23675 return resultobj;
23676 fail:
23677 return NULL;
23678 }
23679
23680
23681 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23682 PyObject *resultobj;
23683 long result;
23684 char *kwnames[] = {
23685 NULL
23686 };
23687
23688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23689 {
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = (long)wxPyApp::GetMacExitMenuItemId();
23692
23693 wxPyEndAllowThreads(__tstate);
23694 if (PyErr_Occurred()) SWIG_fail;
23695 }
23696 {
23697 resultobj = SWIG_From_long((long)(result));
23698 }
23699 return resultobj;
23700 fail:
23701 return NULL;
23702 }
23703
23704
23705 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23706 PyObject *resultobj;
23707 wxString result;
23708 char *kwnames[] = {
23709 NULL
23710 };
23711
23712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = wxPyApp::GetMacHelpMenuTitleName();
23716
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 {
23721 #if wxUSE_UNICODE
23722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23723 #else
23724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23725 #endif
23726 }
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23734 PyObject *resultobj;
23735 bool arg1 ;
23736 PyObject * obj0 = 0 ;
23737 char *kwnames[] = {
23738 (char *) "val", NULL
23739 };
23740
23741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23742 {
23743 arg1 = (bool)(SWIG_As_bool(obj0));
23744 if (SWIG_arg_fail(1)) SWIG_fail;
23745 }
23746 {
23747 PyThreadState* __tstate = wxPyBeginAllowThreads();
23748 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
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_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23761 PyObject *resultobj;
23762 long arg1 ;
23763 PyObject * obj0 = 0 ;
23764 char *kwnames[] = {
23765 (char *) "val", NULL
23766 };
23767
23768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23769 {
23770 arg1 = (long)(SWIG_As_long(obj0));
23771 if (SWIG_arg_fail(1)) SWIG_fail;
23772 }
23773 {
23774 PyThreadState* __tstate = wxPyBeginAllowThreads();
23775 wxPyApp::SetMacAboutMenuItemId(arg1);
23776
23777 wxPyEndAllowThreads(__tstate);
23778 if (PyErr_Occurred()) SWIG_fail;
23779 }
23780 Py_INCREF(Py_None); resultobj = Py_None;
23781 return resultobj;
23782 fail:
23783 return NULL;
23784 }
23785
23786
23787 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23788 PyObject *resultobj;
23789 long arg1 ;
23790 PyObject * obj0 = 0 ;
23791 char *kwnames[] = {
23792 (char *) "val", NULL
23793 };
23794
23795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23796 {
23797 arg1 = (long)(SWIG_As_long(obj0));
23798 if (SWIG_arg_fail(1)) SWIG_fail;
23799 }
23800 {
23801 PyThreadState* __tstate = wxPyBeginAllowThreads();
23802 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23803
23804 wxPyEndAllowThreads(__tstate);
23805 if (PyErr_Occurred()) SWIG_fail;
23806 }
23807 Py_INCREF(Py_None); resultobj = Py_None;
23808 return resultobj;
23809 fail:
23810 return NULL;
23811 }
23812
23813
23814 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23815 PyObject *resultobj;
23816 long arg1 ;
23817 PyObject * obj0 = 0 ;
23818 char *kwnames[] = {
23819 (char *) "val", NULL
23820 };
23821
23822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23823 {
23824 arg1 = (long)(SWIG_As_long(obj0));
23825 if (SWIG_arg_fail(1)) SWIG_fail;
23826 }
23827 {
23828 PyThreadState* __tstate = wxPyBeginAllowThreads();
23829 wxPyApp::SetMacExitMenuItemId(arg1);
23830
23831 wxPyEndAllowThreads(__tstate);
23832 if (PyErr_Occurred()) SWIG_fail;
23833 }
23834 Py_INCREF(Py_None); resultobj = Py_None;
23835 return resultobj;
23836 fail:
23837 return NULL;
23838 }
23839
23840
23841 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23842 PyObject *resultobj;
23843 wxString *arg1 = 0 ;
23844 bool temp1 = false ;
23845 PyObject * obj0 = 0 ;
23846 char *kwnames[] = {
23847 (char *) "val", NULL
23848 };
23849
23850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23851 {
23852 arg1 = wxString_in_helper(obj0);
23853 if (arg1 == NULL) SWIG_fail;
23854 temp1 = true;
23855 }
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23859
23860 wxPyEndAllowThreads(__tstate);
23861 if (PyErr_Occurred()) SWIG_fail;
23862 }
23863 Py_INCREF(Py_None); resultobj = Py_None;
23864 {
23865 if (temp1)
23866 delete arg1;
23867 }
23868 return resultobj;
23869 fail:
23870 {
23871 if (temp1)
23872 delete arg1;
23873 }
23874 return NULL;
23875 }
23876
23877
23878 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23879 PyObject *resultobj;
23880 wxPyApp *arg1 = (wxPyApp *) 0 ;
23881 PyObject * obj0 = 0 ;
23882 char *kwnames[] = {
23883 (char *) "self", NULL
23884 };
23885
23886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23888 if (SWIG_arg_fail(1)) SWIG_fail;
23889 {
23890 PyThreadState* __tstate = wxPyBeginAllowThreads();
23891 (arg1)->_BootstrapApp();
23892
23893 wxPyEndAllowThreads(__tstate);
23894 if (PyErr_Occurred()) SWIG_fail;
23895 }
23896 Py_INCREF(Py_None); resultobj = Py_None;
23897 return resultobj;
23898 fail:
23899 return NULL;
23900 }
23901
23902
23903 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23904 PyObject *resultobj;
23905 int result;
23906 char *kwnames[] = {
23907 NULL
23908 };
23909
23910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 result = (int)PyApp_GetComCtl32Version();
23914
23915 wxPyEndAllowThreads(__tstate);
23916 if (PyErr_Occurred()) SWIG_fail;
23917 }
23918 {
23919 resultobj = SWIG_From_int((int)(result));
23920 }
23921 return resultobj;
23922 fail:
23923 return NULL;
23924 }
23925
23926
23927 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23928 PyObject *obj;
23929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23930 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23931 Py_INCREF(obj);
23932 return Py_BuildValue((char *)"");
23933 }
23934 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23935 PyObject *resultobj;
23936 char *kwnames[] = {
23937 NULL
23938 };
23939
23940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23941 {
23942 PyThreadState* __tstate = wxPyBeginAllowThreads();
23943 wxExit();
23944
23945 wxPyEndAllowThreads(__tstate);
23946 if (PyErr_Occurred()) SWIG_fail;
23947 }
23948 Py_INCREF(Py_None); resultobj = Py_None;
23949 return resultobj;
23950 fail:
23951 return NULL;
23952 }
23953
23954
23955 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23956 PyObject *resultobj;
23957 bool result;
23958 char *kwnames[] = {
23959 NULL
23960 };
23961
23962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23963 {
23964 PyThreadState* __tstate = wxPyBeginAllowThreads();
23965 result = (bool)wxYield();
23966
23967 wxPyEndAllowThreads(__tstate);
23968 if (PyErr_Occurred()) SWIG_fail;
23969 }
23970 {
23971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23972 }
23973 return resultobj;
23974 fail:
23975 return NULL;
23976 }
23977
23978
23979 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23980 PyObject *resultobj;
23981 bool result;
23982 char *kwnames[] = {
23983 NULL
23984 };
23985
23986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23987 {
23988 PyThreadState* __tstate = wxPyBeginAllowThreads();
23989 result = (bool)wxYieldIfNeeded();
23990
23991 wxPyEndAllowThreads(__tstate);
23992 if (PyErr_Occurred()) SWIG_fail;
23993 }
23994 {
23995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23996 }
23997 return resultobj;
23998 fail:
23999 return NULL;
24000 }
24001
24002
24003 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24004 PyObject *resultobj;
24005 wxWindow *arg1 = (wxWindow *) NULL ;
24006 bool arg2 = (bool) false ;
24007 bool result;
24008 PyObject * obj0 = 0 ;
24009 PyObject * obj1 = 0 ;
24010 char *kwnames[] = {
24011 (char *) "win",(char *) "onlyIfNeeded", NULL
24012 };
24013
24014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24015 if (obj0) {
24016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24017 if (SWIG_arg_fail(1)) SWIG_fail;
24018 }
24019 if (obj1) {
24020 {
24021 arg2 = (bool)(SWIG_As_bool(obj1));
24022 if (SWIG_arg_fail(2)) SWIG_fail;
24023 }
24024 }
24025 {
24026 PyThreadState* __tstate = wxPyBeginAllowThreads();
24027 result = (bool)wxSafeYield(arg1,arg2);
24028
24029 wxPyEndAllowThreads(__tstate);
24030 if (PyErr_Occurred()) SWIG_fail;
24031 }
24032 {
24033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24034 }
24035 return resultobj;
24036 fail:
24037 return NULL;
24038 }
24039
24040
24041 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24042 PyObject *resultobj;
24043 char *kwnames[] = {
24044 NULL
24045 };
24046
24047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24048 {
24049 PyThreadState* __tstate = wxPyBeginAllowThreads();
24050 wxWakeUpIdle();
24051
24052 wxPyEndAllowThreads(__tstate);
24053 if (PyErr_Occurred()) SWIG_fail;
24054 }
24055 Py_INCREF(Py_None); resultobj = Py_None;
24056 return resultobj;
24057 fail:
24058 return NULL;
24059 }
24060
24061
24062 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24063 PyObject *resultobj;
24064 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24065 wxEvent *arg2 = 0 ;
24066 PyObject * obj0 = 0 ;
24067 PyObject * obj1 = 0 ;
24068 char *kwnames[] = {
24069 (char *) "dest",(char *) "event", NULL
24070 };
24071
24072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24074 if (SWIG_arg_fail(1)) SWIG_fail;
24075 {
24076 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24077 if (SWIG_arg_fail(2)) SWIG_fail;
24078 if (arg2 == NULL) {
24079 SWIG_null_ref("wxEvent");
24080 }
24081 if (SWIG_arg_fail(2)) SWIG_fail;
24082 }
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 wxPostEvent(arg1,*arg2);
24086
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 Py_INCREF(Py_None); resultobj = Py_None;
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj;
24099 char *kwnames[] = {
24100 NULL
24101 };
24102
24103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24104 {
24105 PyThreadState* __tstate = wxPyBeginAllowThreads();
24106 wxApp_CleanUp();
24107
24108 wxPyEndAllowThreads(__tstate);
24109 if (PyErr_Occurred()) SWIG_fail;
24110 }
24111 Py_INCREF(Py_None); resultobj = Py_None;
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj;
24120 wxPyApp *result;
24121 char *kwnames[] = {
24122 NULL
24123 };
24124
24125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24126 {
24127 PyThreadState* __tstate = wxPyBeginAllowThreads();
24128 result = (wxPyApp *)wxPyGetApp();
24129
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 {
24134 resultobj = wxPyMake_wxObject(result, 0);
24135 }
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24143 PyObject *resultobj;
24144 char *arg1 = (char *) 0 ;
24145 PyObject * obj0 = 0 ;
24146 char *kwnames[] = {
24147 (char *) "encoding", NULL
24148 };
24149
24150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24151 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24152 SWIG_arg_fail(1);SWIG_fail;
24153 }
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 wxSetDefaultPyEncoding((char const *)arg1);
24157
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 Py_INCREF(Py_None); resultobj = Py_None;
24162 return resultobj;
24163 fail:
24164 return NULL;
24165 }
24166
24167
24168 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24169 PyObject *resultobj;
24170 char *result;
24171 char *kwnames[] = {
24172 NULL
24173 };
24174
24175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24176 {
24177 PyThreadState* __tstate = wxPyBeginAllowThreads();
24178 result = (char *)wxGetDefaultPyEncoding();
24179
24180 wxPyEndAllowThreads(__tstate);
24181 if (PyErr_Occurred()) SWIG_fail;
24182 }
24183 resultobj = SWIG_FromCharPtr(result);
24184 return resultobj;
24185 fail:
24186 return NULL;
24187 }
24188
24189
24190 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24191 PyObject *resultobj;
24192 wxEventLoop *result;
24193 char *kwnames[] = {
24194 NULL
24195 };
24196
24197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = (wxEventLoop *)new wxEventLoop();
24201
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24213 PyObject *resultobj;
24214 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24215 PyObject * obj0 = 0 ;
24216 char *kwnames[] = {
24217 (char *) "self", NULL
24218 };
24219
24220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24222 if (SWIG_arg_fail(1)) SWIG_fail;
24223 {
24224 PyThreadState* __tstate = wxPyBeginAllowThreads();
24225 delete arg1;
24226
24227 wxPyEndAllowThreads(__tstate);
24228 if (PyErr_Occurred()) SWIG_fail;
24229 }
24230 Py_INCREF(Py_None); resultobj = Py_None;
24231 return resultobj;
24232 fail:
24233 return NULL;
24234 }
24235
24236
24237 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24238 PyObject *resultobj;
24239 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24240 int result;
24241 PyObject * obj0 = 0 ;
24242 char *kwnames[] = {
24243 (char *) "self", NULL
24244 };
24245
24246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24248 if (SWIG_arg_fail(1)) SWIG_fail;
24249 {
24250 PyThreadState* __tstate = wxPyBeginAllowThreads();
24251 result = (int)(arg1)->Run();
24252
24253 wxPyEndAllowThreads(__tstate);
24254 if (PyErr_Occurred()) SWIG_fail;
24255 }
24256 {
24257 resultobj = SWIG_From_int((int)(result));
24258 }
24259 return resultobj;
24260 fail:
24261 return NULL;
24262 }
24263
24264
24265 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24266 PyObject *resultobj;
24267 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24268 int arg2 = (int) 0 ;
24269 PyObject * obj0 = 0 ;
24270 PyObject * obj1 = 0 ;
24271 char *kwnames[] = {
24272 (char *) "self",(char *) "rc", NULL
24273 };
24274
24275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24277 if (SWIG_arg_fail(1)) SWIG_fail;
24278 if (obj1) {
24279 {
24280 arg2 = (int)(SWIG_As_int(obj1));
24281 if (SWIG_arg_fail(2)) SWIG_fail;
24282 }
24283 }
24284 {
24285 PyThreadState* __tstate = wxPyBeginAllowThreads();
24286 (arg1)->Exit(arg2);
24287
24288 wxPyEndAllowThreads(__tstate);
24289 if (PyErr_Occurred()) SWIG_fail;
24290 }
24291 Py_INCREF(Py_None); resultobj = Py_None;
24292 return resultobj;
24293 fail:
24294 return NULL;
24295 }
24296
24297
24298 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24299 PyObject *resultobj;
24300 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24301 bool result;
24302 PyObject * obj0 = 0 ;
24303 char *kwnames[] = {
24304 (char *) "self", NULL
24305 };
24306
24307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24309 if (SWIG_arg_fail(1)) SWIG_fail;
24310 {
24311 PyThreadState* __tstate = wxPyBeginAllowThreads();
24312 result = (bool)((wxEventLoop const *)arg1)->Pending();
24313
24314 wxPyEndAllowThreads(__tstate);
24315 if (PyErr_Occurred()) SWIG_fail;
24316 }
24317 {
24318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24319 }
24320 return resultobj;
24321 fail:
24322 return NULL;
24323 }
24324
24325
24326 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24327 PyObject *resultobj;
24328 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24329 bool result;
24330 PyObject * obj0 = 0 ;
24331 char *kwnames[] = {
24332 (char *) "self", NULL
24333 };
24334
24335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24337 if (SWIG_arg_fail(1)) SWIG_fail;
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 result = (bool)(arg1)->Dispatch();
24341
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 {
24346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24347 }
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24355 PyObject *resultobj;
24356 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24357 bool result;
24358 PyObject * obj0 = 0 ;
24359 char *kwnames[] = {
24360 (char *) "self", NULL
24361 };
24362
24363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24365 if (SWIG_arg_fail(1)) SWIG_fail;
24366 {
24367 PyThreadState* __tstate = wxPyBeginAllowThreads();
24368 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24369
24370 wxPyEndAllowThreads(__tstate);
24371 if (PyErr_Occurred()) SWIG_fail;
24372 }
24373 {
24374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24375 }
24376 return resultobj;
24377 fail:
24378 return NULL;
24379 }
24380
24381
24382 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24383 PyObject *resultobj;
24384 wxEventLoop *result;
24385 char *kwnames[] = {
24386 NULL
24387 };
24388
24389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 result = (wxEventLoop *)wxEventLoop::GetActive();
24393
24394 wxPyEndAllowThreads(__tstate);
24395 if (PyErr_Occurred()) SWIG_fail;
24396 }
24397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24405 PyObject *resultobj;
24406 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24407 PyObject * obj0 = 0 ;
24408 char *kwnames[] = {
24409 (char *) "loop", NULL
24410 };
24411
24412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24414 if (SWIG_arg_fail(1)) SWIG_fail;
24415 {
24416 PyThreadState* __tstate = wxPyBeginAllowThreads();
24417 wxEventLoop::SetActive(arg1);
24418
24419 wxPyEndAllowThreads(__tstate);
24420 if (PyErr_Occurred()) SWIG_fail;
24421 }
24422 Py_INCREF(Py_None); resultobj = Py_None;
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24430 PyObject *obj;
24431 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24432 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24433 Py_INCREF(obj);
24434 return Py_BuildValue((char *)"");
24435 }
24436 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24437 PyObject *resultobj;
24438 int arg1 = (int) 0 ;
24439 int arg2 = (int) 0 ;
24440 int arg3 = (int) 0 ;
24441 wxAcceleratorEntry *result;
24442 PyObject * obj0 = 0 ;
24443 PyObject * obj1 = 0 ;
24444 PyObject * obj2 = 0 ;
24445 char *kwnames[] = {
24446 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24447 };
24448
24449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24450 if (obj0) {
24451 {
24452 arg1 = (int)(SWIG_As_int(obj0));
24453 if (SWIG_arg_fail(1)) SWIG_fail;
24454 }
24455 }
24456 if (obj1) {
24457 {
24458 arg2 = (int)(SWIG_As_int(obj1));
24459 if (SWIG_arg_fail(2)) SWIG_fail;
24460 }
24461 }
24462 if (obj2) {
24463 {
24464 arg3 = (int)(SWIG_As_int(obj2));
24465 if (SWIG_arg_fail(3)) SWIG_fail;
24466 }
24467 }
24468 {
24469 PyThreadState* __tstate = wxPyBeginAllowThreads();
24470 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24471
24472 wxPyEndAllowThreads(__tstate);
24473 if (PyErr_Occurred()) SWIG_fail;
24474 }
24475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24483 PyObject *resultobj;
24484 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24485 PyObject * obj0 = 0 ;
24486 char *kwnames[] = {
24487 (char *) "self", NULL
24488 };
24489
24490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24492 if (SWIG_arg_fail(1)) SWIG_fail;
24493 {
24494 PyThreadState* __tstate = wxPyBeginAllowThreads();
24495 delete arg1;
24496
24497 wxPyEndAllowThreads(__tstate);
24498 if (PyErr_Occurred()) SWIG_fail;
24499 }
24500 Py_INCREF(Py_None); resultobj = Py_None;
24501 return resultobj;
24502 fail:
24503 return NULL;
24504 }
24505
24506
24507 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24508 PyObject *resultobj;
24509 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24510 int arg2 ;
24511 int arg3 ;
24512 int arg4 ;
24513 PyObject * obj0 = 0 ;
24514 PyObject * obj1 = 0 ;
24515 PyObject * obj2 = 0 ;
24516 PyObject * obj3 = 0 ;
24517 char *kwnames[] = {
24518 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24519 };
24520
24521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24523 if (SWIG_arg_fail(1)) SWIG_fail;
24524 {
24525 arg2 = (int)(SWIG_As_int(obj1));
24526 if (SWIG_arg_fail(2)) SWIG_fail;
24527 }
24528 {
24529 arg3 = (int)(SWIG_As_int(obj2));
24530 if (SWIG_arg_fail(3)) SWIG_fail;
24531 }
24532 {
24533 arg4 = (int)(SWIG_As_int(obj3));
24534 if (SWIG_arg_fail(4)) SWIG_fail;
24535 }
24536 {
24537 PyThreadState* __tstate = wxPyBeginAllowThreads();
24538 (arg1)->Set(arg2,arg3,arg4);
24539
24540 wxPyEndAllowThreads(__tstate);
24541 if (PyErr_Occurred()) SWIG_fail;
24542 }
24543 Py_INCREF(Py_None); resultobj = Py_None;
24544 return resultobj;
24545 fail:
24546 return NULL;
24547 }
24548
24549
24550 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24551 PyObject *resultobj;
24552 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24553 int result;
24554 PyObject * obj0 = 0 ;
24555 char *kwnames[] = {
24556 (char *) "self", NULL
24557 };
24558
24559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24561 if (SWIG_arg_fail(1)) SWIG_fail;
24562 {
24563 PyThreadState* __tstate = wxPyBeginAllowThreads();
24564 result = (int)(arg1)->GetFlags();
24565
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 {
24570 resultobj = SWIG_From_int((int)(result));
24571 }
24572 return resultobj;
24573 fail:
24574 return NULL;
24575 }
24576
24577
24578 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24579 PyObject *resultobj;
24580 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24581 int result;
24582 PyObject * obj0 = 0 ;
24583 char *kwnames[] = {
24584 (char *) "self", NULL
24585 };
24586
24587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24589 if (SWIG_arg_fail(1)) SWIG_fail;
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 result = (int)(arg1)->GetKeyCode();
24593
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 {
24598 resultobj = SWIG_From_int((int)(result));
24599 }
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24607 PyObject *resultobj;
24608 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24609 int result;
24610 PyObject * obj0 = 0 ;
24611 char *kwnames[] = {
24612 (char *) "self", NULL
24613 };
24614
24615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24617 if (SWIG_arg_fail(1)) SWIG_fail;
24618 {
24619 PyThreadState* __tstate = wxPyBeginAllowThreads();
24620 result = (int)(arg1)->GetCommand();
24621
24622 wxPyEndAllowThreads(__tstate);
24623 if (PyErr_Occurred()) SWIG_fail;
24624 }
24625 {
24626 resultobj = SWIG_From_int((int)(result));
24627 }
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24635 PyObject *obj;
24636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24637 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24638 Py_INCREF(obj);
24639 return Py_BuildValue((char *)"");
24640 }
24641 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj;
24643 int arg1 ;
24644 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24645 wxAcceleratorTable *result;
24646 PyObject * obj0 = 0 ;
24647 char *kwnames[] = {
24648 (char *) "n", NULL
24649 };
24650
24651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24652 {
24653 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24654 if (arg2) arg1 = PyList_Size(obj0);
24655 else arg1 = 0;
24656 }
24657 {
24658 PyThreadState* __tstate = wxPyBeginAllowThreads();
24659 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24660
24661 wxPyEndAllowThreads(__tstate);
24662 if (PyErr_Occurred()) SWIG_fail;
24663 }
24664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24665 {
24666 delete [] arg2;
24667 }
24668 return resultobj;
24669 fail:
24670 {
24671 delete [] arg2;
24672 }
24673 return NULL;
24674 }
24675
24676
24677 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24678 PyObject *resultobj;
24679 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24680 PyObject * obj0 = 0 ;
24681 char *kwnames[] = {
24682 (char *) "self", NULL
24683 };
24684
24685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24687 if (SWIG_arg_fail(1)) SWIG_fail;
24688 {
24689 PyThreadState* __tstate = wxPyBeginAllowThreads();
24690 delete arg1;
24691
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 Py_INCREF(Py_None); resultobj = Py_None;
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24703 PyObject *resultobj;
24704 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24705 bool result;
24706 PyObject * obj0 = 0 ;
24707 char *kwnames[] = {
24708 (char *) "self", NULL
24709 };
24710
24711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24713 if (SWIG_arg_fail(1)) SWIG_fail;
24714 {
24715 PyThreadState* __tstate = wxPyBeginAllowThreads();
24716 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24717
24718 wxPyEndAllowThreads(__tstate);
24719 if (PyErr_Occurred()) SWIG_fail;
24720 }
24721 {
24722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24723 }
24724 return resultobj;
24725 fail:
24726 return NULL;
24727 }
24728
24729
24730 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24731 PyObject *obj;
24732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24733 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24734 Py_INCREF(obj);
24735 return Py_BuildValue((char *)"");
24736 }
24737 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24738 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24739 return 1;
24740 }
24741
24742
24743 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24744 PyObject *pyobj;
24745
24746 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24747 return pyobj;
24748 }
24749
24750
24751 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24752 PyObject *resultobj;
24753 wxString *arg1 = 0 ;
24754 wxAcceleratorEntry *result;
24755 bool temp1 = false ;
24756 PyObject * obj0 = 0 ;
24757 char *kwnames[] = {
24758 (char *) "label", NULL
24759 };
24760
24761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24762 {
24763 arg1 = wxString_in_helper(obj0);
24764 if (arg1 == NULL) SWIG_fail;
24765 temp1 = true;
24766 }
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24770
24771 wxPyEndAllowThreads(__tstate);
24772 if (PyErr_Occurred()) SWIG_fail;
24773 }
24774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24775 {
24776 if (temp1)
24777 delete arg1;
24778 }
24779 return resultobj;
24780 fail:
24781 {
24782 if (temp1)
24783 delete arg1;
24784 }
24785 return NULL;
24786 }
24787
24788
24789 static int _wrap_PanelNameStr_set(PyObject *) {
24790 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24791 return 1;
24792 }
24793
24794
24795 static PyObject *_wrap_PanelNameStr_get(void) {
24796 PyObject *pyobj;
24797
24798 {
24799 #if wxUSE_UNICODE
24800 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24801 #else
24802 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24803 #endif
24804 }
24805 return pyobj;
24806 }
24807
24808
24809 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24810 PyObject *resultobj;
24811 wxVisualAttributes *result;
24812 char *kwnames[] = {
24813 NULL
24814 };
24815
24816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24817 {
24818 PyThreadState* __tstate = wxPyBeginAllowThreads();
24819 result = (wxVisualAttributes *)new_wxVisualAttributes();
24820
24821 wxPyEndAllowThreads(__tstate);
24822 if (PyErr_Occurred()) SWIG_fail;
24823 }
24824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj;
24833 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24834 PyObject * obj0 = 0 ;
24835 char *kwnames[] = {
24836 (char *) "self", NULL
24837 };
24838
24839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24841 if (SWIG_arg_fail(1)) SWIG_fail;
24842 {
24843 PyThreadState* __tstate = wxPyBeginAllowThreads();
24844 delete_wxVisualAttributes(arg1);
24845
24846 wxPyEndAllowThreads(__tstate);
24847 if (PyErr_Occurred()) SWIG_fail;
24848 }
24849 Py_INCREF(Py_None); resultobj = Py_None;
24850 return resultobj;
24851 fail:
24852 return NULL;
24853 }
24854
24855
24856 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24857 PyObject *resultobj;
24858 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24859 wxFont *arg2 = (wxFont *) 0 ;
24860 PyObject * obj0 = 0 ;
24861 PyObject * obj1 = 0 ;
24862 char *kwnames[] = {
24863 (char *) "self",(char *) "font", NULL
24864 };
24865
24866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24868 if (SWIG_arg_fail(1)) SWIG_fail;
24869 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24870 if (SWIG_arg_fail(2)) SWIG_fail;
24871 if (arg1) (arg1)->font = *arg2;
24872
24873 Py_INCREF(Py_None); resultobj = Py_None;
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj;
24882 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24883 wxFont *result;
24884 PyObject * obj0 = 0 ;
24885 char *kwnames[] = {
24886 (char *) "self", NULL
24887 };
24888
24889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24891 if (SWIG_arg_fail(1)) SWIG_fail;
24892 result = (wxFont *)& ((arg1)->font);
24893
24894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24895 return resultobj;
24896 fail:
24897 return NULL;
24898 }
24899
24900
24901 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24902 PyObject *resultobj;
24903 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24904 wxColour *arg2 = (wxColour *) 0 ;
24905 PyObject * obj0 = 0 ;
24906 PyObject * obj1 = 0 ;
24907 char *kwnames[] = {
24908 (char *) "self",(char *) "colFg", NULL
24909 };
24910
24911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24913 if (SWIG_arg_fail(1)) SWIG_fail;
24914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24915 if (SWIG_arg_fail(2)) SWIG_fail;
24916 if (arg1) (arg1)->colFg = *arg2;
24917
24918 Py_INCREF(Py_None); resultobj = Py_None;
24919 return resultobj;
24920 fail:
24921 return NULL;
24922 }
24923
24924
24925 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24926 PyObject *resultobj;
24927 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24928 wxColour *result;
24929 PyObject * obj0 = 0 ;
24930 char *kwnames[] = {
24931 (char *) "self", NULL
24932 };
24933
24934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24936 if (SWIG_arg_fail(1)) SWIG_fail;
24937 result = (wxColour *)& ((arg1)->colFg);
24938
24939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24947 PyObject *resultobj;
24948 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24949 wxColour *arg2 = (wxColour *) 0 ;
24950 PyObject * obj0 = 0 ;
24951 PyObject * obj1 = 0 ;
24952 char *kwnames[] = {
24953 (char *) "self",(char *) "colBg", NULL
24954 };
24955
24956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24958 if (SWIG_arg_fail(1)) SWIG_fail;
24959 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24960 if (SWIG_arg_fail(2)) SWIG_fail;
24961 if (arg1) (arg1)->colBg = *arg2;
24962
24963 Py_INCREF(Py_None); resultobj = Py_None;
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24971 PyObject *resultobj;
24972 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24973 wxColour *result;
24974 PyObject * obj0 = 0 ;
24975 char *kwnames[] = {
24976 (char *) "self", NULL
24977 };
24978
24979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24981 if (SWIG_arg_fail(1)) SWIG_fail;
24982 result = (wxColour *)& ((arg1)->colBg);
24983
24984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24985 return resultobj;
24986 fail:
24987 return NULL;
24988 }
24989
24990
24991 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24992 PyObject *obj;
24993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24994 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24995 Py_INCREF(obj);
24996 return Py_BuildValue((char *)"");
24997 }
24998 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24999 PyObject *resultobj;
25000 wxWindow *arg1 = (wxWindow *) 0 ;
25001 int arg2 = (int) (int)-1 ;
25002 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25003 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25004 wxSize const &arg4_defvalue = wxDefaultSize ;
25005 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25006 long arg5 = (long) 0 ;
25007 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25008 wxString *arg6 = (wxString *) &arg6_defvalue ;
25009 wxWindow *result;
25010 wxPoint temp3 ;
25011 wxSize temp4 ;
25012 bool temp6 = false ;
25013 PyObject * obj0 = 0 ;
25014 PyObject * obj1 = 0 ;
25015 PyObject * obj2 = 0 ;
25016 PyObject * obj3 = 0 ;
25017 PyObject * obj4 = 0 ;
25018 PyObject * obj5 = 0 ;
25019 char *kwnames[] = {
25020 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25021 };
25022
25023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25025 if (SWIG_arg_fail(1)) SWIG_fail;
25026 if (obj1) {
25027 {
25028 arg2 = (int const)(SWIG_As_int(obj1));
25029 if (SWIG_arg_fail(2)) SWIG_fail;
25030 }
25031 }
25032 if (obj2) {
25033 {
25034 arg3 = &temp3;
25035 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25036 }
25037 }
25038 if (obj3) {
25039 {
25040 arg4 = &temp4;
25041 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25042 }
25043 }
25044 if (obj4) {
25045 {
25046 arg5 = (long)(SWIG_As_long(obj4));
25047 if (SWIG_arg_fail(5)) SWIG_fail;
25048 }
25049 }
25050 if (obj5) {
25051 {
25052 arg6 = wxString_in_helper(obj5);
25053 if (arg6 == NULL) SWIG_fail;
25054 temp6 = true;
25055 }
25056 }
25057 {
25058 if (!wxPyCheckForApp()) SWIG_fail;
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25061
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25066 {
25067 if (temp6)
25068 delete arg6;
25069 }
25070 return resultobj;
25071 fail:
25072 {
25073 if (temp6)
25074 delete arg6;
25075 }
25076 return NULL;
25077 }
25078
25079
25080 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25081 PyObject *resultobj;
25082 wxWindow *result;
25083 char *kwnames[] = {
25084 NULL
25085 };
25086
25087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25088 {
25089 if (!wxPyCheckForApp()) SWIG_fail;
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 result = (wxWindow *)new wxWindow();
25092
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25097 return resultobj;
25098 fail:
25099 return NULL;
25100 }
25101
25102
25103 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25104 PyObject *resultobj;
25105 wxWindow *arg1 = (wxWindow *) 0 ;
25106 wxWindow *arg2 = (wxWindow *) 0 ;
25107 int arg3 = (int) (int)-1 ;
25108 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25109 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25110 wxSize const &arg5_defvalue = wxDefaultSize ;
25111 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25112 long arg6 = (long) 0 ;
25113 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25114 wxString *arg7 = (wxString *) &arg7_defvalue ;
25115 bool result;
25116 wxPoint temp4 ;
25117 wxSize temp5 ;
25118 bool temp7 = false ;
25119 PyObject * obj0 = 0 ;
25120 PyObject * obj1 = 0 ;
25121 PyObject * obj2 = 0 ;
25122 PyObject * obj3 = 0 ;
25123 PyObject * obj4 = 0 ;
25124 PyObject * obj5 = 0 ;
25125 PyObject * obj6 = 0 ;
25126 char *kwnames[] = {
25127 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25128 };
25129
25130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25132 if (SWIG_arg_fail(1)) SWIG_fail;
25133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25134 if (SWIG_arg_fail(2)) SWIG_fail;
25135 if (obj2) {
25136 {
25137 arg3 = (int const)(SWIG_As_int(obj2));
25138 if (SWIG_arg_fail(3)) SWIG_fail;
25139 }
25140 }
25141 if (obj3) {
25142 {
25143 arg4 = &temp4;
25144 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25145 }
25146 }
25147 if (obj4) {
25148 {
25149 arg5 = &temp5;
25150 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25151 }
25152 }
25153 if (obj5) {
25154 {
25155 arg6 = (long)(SWIG_As_long(obj5));
25156 if (SWIG_arg_fail(6)) SWIG_fail;
25157 }
25158 }
25159 if (obj6) {
25160 {
25161 arg7 = wxString_in_helper(obj6);
25162 if (arg7 == NULL) SWIG_fail;
25163 temp7 = true;
25164 }
25165 }
25166 {
25167 PyThreadState* __tstate = wxPyBeginAllowThreads();
25168 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25169
25170 wxPyEndAllowThreads(__tstate);
25171 if (PyErr_Occurred()) SWIG_fail;
25172 }
25173 {
25174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25175 }
25176 {
25177 if (temp7)
25178 delete arg7;
25179 }
25180 return resultobj;
25181 fail:
25182 {
25183 if (temp7)
25184 delete arg7;
25185 }
25186 return NULL;
25187 }
25188
25189
25190 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25191 PyObject *resultobj;
25192 wxWindow *arg1 = (wxWindow *) 0 ;
25193 bool arg2 = (bool) false ;
25194 bool result;
25195 PyObject * obj0 = 0 ;
25196 PyObject * obj1 = 0 ;
25197 char *kwnames[] = {
25198 (char *) "self",(char *) "force", NULL
25199 };
25200
25201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25203 if (SWIG_arg_fail(1)) SWIG_fail;
25204 if (obj1) {
25205 {
25206 arg2 = (bool)(SWIG_As_bool(obj1));
25207 if (SWIG_arg_fail(2)) SWIG_fail;
25208 }
25209 }
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = (bool)(arg1)->Close(arg2);
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25227 PyObject *resultobj;
25228 wxWindow *arg1 = (wxWindow *) 0 ;
25229 bool result;
25230 PyObject * obj0 = 0 ;
25231 char *kwnames[] = {
25232 (char *) "self", NULL
25233 };
25234
25235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25237 if (SWIG_arg_fail(1)) SWIG_fail;
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 result = (bool)(arg1)->Destroy();
25241
25242 wxPyEndAllowThreads(__tstate);
25243 if (PyErr_Occurred()) SWIG_fail;
25244 }
25245 {
25246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25247 }
25248 return resultobj;
25249 fail:
25250 return NULL;
25251 }
25252
25253
25254 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj;
25256 wxWindow *arg1 = (wxWindow *) 0 ;
25257 bool result;
25258 PyObject * obj0 = 0 ;
25259 char *kwnames[] = {
25260 (char *) "self", NULL
25261 };
25262
25263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25265 if (SWIG_arg_fail(1)) SWIG_fail;
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 result = (bool)(arg1)->DestroyChildren();
25269
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 {
25274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25275 }
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25283 PyObject *resultobj;
25284 wxWindow *arg1 = (wxWindow *) 0 ;
25285 bool result;
25286 PyObject * obj0 = 0 ;
25287 char *kwnames[] = {
25288 (char *) "self", NULL
25289 };
25290
25291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25293 if (SWIG_arg_fail(1)) SWIG_fail;
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25297
25298 wxPyEndAllowThreads(__tstate);
25299 if (PyErr_Occurred()) SWIG_fail;
25300 }
25301 {
25302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25303 }
25304 return resultobj;
25305 fail:
25306 return NULL;
25307 }
25308
25309
25310 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25311 PyObject *resultobj;
25312 wxWindow *arg1 = (wxWindow *) 0 ;
25313 wxString *arg2 = 0 ;
25314 bool temp2 = false ;
25315 PyObject * obj0 = 0 ;
25316 PyObject * obj1 = 0 ;
25317 char *kwnames[] = {
25318 (char *) "self",(char *) "title", NULL
25319 };
25320
25321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25323 if (SWIG_arg_fail(1)) SWIG_fail;
25324 {
25325 arg2 = wxString_in_helper(obj1);
25326 if (arg2 == NULL) SWIG_fail;
25327 temp2 = true;
25328 }
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 (arg1)->SetTitle((wxString const &)*arg2);
25332
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 Py_INCREF(Py_None); resultobj = Py_None;
25337 {
25338 if (temp2)
25339 delete arg2;
25340 }
25341 return resultobj;
25342 fail:
25343 {
25344 if (temp2)
25345 delete arg2;
25346 }
25347 return NULL;
25348 }
25349
25350
25351 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25352 PyObject *resultobj;
25353 wxWindow *arg1 = (wxWindow *) 0 ;
25354 wxString result;
25355 PyObject * obj0 = 0 ;
25356 char *kwnames[] = {
25357 (char *) "self", NULL
25358 };
25359
25360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25362 if (SWIG_arg_fail(1)) SWIG_fail;
25363 {
25364 PyThreadState* __tstate = wxPyBeginAllowThreads();
25365 result = ((wxWindow const *)arg1)->GetTitle();
25366
25367 wxPyEndAllowThreads(__tstate);
25368 if (PyErr_Occurred()) SWIG_fail;
25369 }
25370 {
25371 #if wxUSE_UNICODE
25372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25373 #else
25374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25375 #endif
25376 }
25377 return resultobj;
25378 fail:
25379 return NULL;
25380 }
25381
25382
25383 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25384 PyObject *resultobj;
25385 wxWindow *arg1 = (wxWindow *) 0 ;
25386 wxString *arg2 = 0 ;
25387 bool temp2 = false ;
25388 PyObject * obj0 = 0 ;
25389 PyObject * obj1 = 0 ;
25390 char *kwnames[] = {
25391 (char *) "self",(char *) "label", NULL
25392 };
25393
25394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25396 if (SWIG_arg_fail(1)) SWIG_fail;
25397 {
25398 arg2 = wxString_in_helper(obj1);
25399 if (arg2 == NULL) SWIG_fail;
25400 temp2 = true;
25401 }
25402 {
25403 PyThreadState* __tstate = wxPyBeginAllowThreads();
25404 (arg1)->SetLabel((wxString const &)*arg2);
25405
25406 wxPyEndAllowThreads(__tstate);
25407 if (PyErr_Occurred()) SWIG_fail;
25408 }
25409 Py_INCREF(Py_None); resultobj = Py_None;
25410 {
25411 if (temp2)
25412 delete arg2;
25413 }
25414 return resultobj;
25415 fail:
25416 {
25417 if (temp2)
25418 delete arg2;
25419 }
25420 return NULL;
25421 }
25422
25423
25424 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25425 PyObject *resultobj;
25426 wxWindow *arg1 = (wxWindow *) 0 ;
25427 wxString result;
25428 PyObject * obj0 = 0 ;
25429 char *kwnames[] = {
25430 (char *) "self", NULL
25431 };
25432
25433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25435 if (SWIG_arg_fail(1)) SWIG_fail;
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = ((wxWindow const *)arg1)->GetLabel();
25439
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 {
25444 #if wxUSE_UNICODE
25445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25446 #else
25447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25448 #endif
25449 }
25450 return resultobj;
25451 fail:
25452 return NULL;
25453 }
25454
25455
25456 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25457 PyObject *resultobj;
25458 wxWindow *arg1 = (wxWindow *) 0 ;
25459 wxString *arg2 = 0 ;
25460 bool temp2 = false ;
25461 PyObject * obj0 = 0 ;
25462 PyObject * obj1 = 0 ;
25463 char *kwnames[] = {
25464 (char *) "self",(char *) "name", NULL
25465 };
25466
25467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25469 if (SWIG_arg_fail(1)) SWIG_fail;
25470 {
25471 arg2 = wxString_in_helper(obj1);
25472 if (arg2 == NULL) SWIG_fail;
25473 temp2 = true;
25474 }
25475 {
25476 PyThreadState* __tstate = wxPyBeginAllowThreads();
25477 (arg1)->SetName((wxString const &)*arg2);
25478
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 Py_INCREF(Py_None); resultobj = Py_None;
25483 {
25484 if (temp2)
25485 delete arg2;
25486 }
25487 return resultobj;
25488 fail:
25489 {
25490 if (temp2)
25491 delete arg2;
25492 }
25493 return NULL;
25494 }
25495
25496
25497 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25498 PyObject *resultobj;
25499 wxWindow *arg1 = (wxWindow *) 0 ;
25500 wxString result;
25501 PyObject * obj0 = 0 ;
25502 char *kwnames[] = {
25503 (char *) "self", NULL
25504 };
25505
25506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25508 if (SWIG_arg_fail(1)) SWIG_fail;
25509 {
25510 PyThreadState* __tstate = wxPyBeginAllowThreads();
25511 result = ((wxWindow const *)arg1)->GetName();
25512
25513 wxPyEndAllowThreads(__tstate);
25514 if (PyErr_Occurred()) SWIG_fail;
25515 }
25516 {
25517 #if wxUSE_UNICODE
25518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25519 #else
25520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25521 #endif
25522 }
25523 return resultobj;
25524 fail:
25525 return NULL;
25526 }
25527
25528
25529 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25530 PyObject *resultobj;
25531 wxWindow *arg1 = (wxWindow *) 0 ;
25532 wxWindowVariant arg2 ;
25533 PyObject * obj0 = 0 ;
25534 PyObject * obj1 = 0 ;
25535 char *kwnames[] = {
25536 (char *) "self",(char *) "variant", NULL
25537 };
25538
25539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25541 if (SWIG_arg_fail(1)) SWIG_fail;
25542 {
25543 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25544 if (SWIG_arg_fail(2)) SWIG_fail;
25545 }
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25549
25550 wxPyEndAllowThreads(__tstate);
25551 if (PyErr_Occurred()) SWIG_fail;
25552 }
25553 Py_INCREF(Py_None); resultobj = Py_None;
25554 return resultobj;
25555 fail:
25556 return NULL;
25557 }
25558
25559
25560 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25561 PyObject *resultobj;
25562 wxWindow *arg1 = (wxWindow *) 0 ;
25563 wxWindowVariant result;
25564 PyObject * obj0 = 0 ;
25565 char *kwnames[] = {
25566 (char *) "self", NULL
25567 };
25568
25569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25571 if (SWIG_arg_fail(1)) SWIG_fail;
25572 {
25573 PyThreadState* __tstate = wxPyBeginAllowThreads();
25574 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25575
25576 wxPyEndAllowThreads(__tstate);
25577 if (PyErr_Occurred()) SWIG_fail;
25578 }
25579 resultobj = SWIG_From_int((result));
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25587 PyObject *resultobj;
25588 wxWindow *arg1 = (wxWindow *) 0 ;
25589 int arg2 ;
25590 PyObject * obj0 = 0 ;
25591 PyObject * obj1 = 0 ;
25592 char *kwnames[] = {
25593 (char *) "self",(char *) "winid", NULL
25594 };
25595
25596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25598 if (SWIG_arg_fail(1)) SWIG_fail;
25599 {
25600 arg2 = (int)(SWIG_As_int(obj1));
25601 if (SWIG_arg_fail(2)) SWIG_fail;
25602 }
25603 {
25604 PyThreadState* __tstate = wxPyBeginAllowThreads();
25605 (arg1)->SetId(arg2);
25606
25607 wxPyEndAllowThreads(__tstate);
25608 if (PyErr_Occurred()) SWIG_fail;
25609 }
25610 Py_INCREF(Py_None); resultobj = Py_None;
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25618 PyObject *resultobj;
25619 wxWindow *arg1 = (wxWindow *) 0 ;
25620 int result;
25621 PyObject * obj0 = 0 ;
25622 char *kwnames[] = {
25623 (char *) "self", NULL
25624 };
25625
25626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25628 if (SWIG_arg_fail(1)) SWIG_fail;
25629 {
25630 PyThreadState* __tstate = wxPyBeginAllowThreads();
25631 result = (int)((wxWindow const *)arg1)->GetId();
25632
25633 wxPyEndAllowThreads(__tstate);
25634 if (PyErr_Occurred()) SWIG_fail;
25635 }
25636 {
25637 resultobj = SWIG_From_int((int)(result));
25638 }
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25646 PyObject *resultobj;
25647 int result;
25648 char *kwnames[] = {
25649 NULL
25650 };
25651
25652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25653 {
25654 PyThreadState* __tstate = wxPyBeginAllowThreads();
25655 result = (int)wxWindow::NewControlId();
25656
25657 wxPyEndAllowThreads(__tstate);
25658 if (PyErr_Occurred()) SWIG_fail;
25659 }
25660 {
25661 resultobj = SWIG_From_int((int)(result));
25662 }
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25670 PyObject *resultobj;
25671 int arg1 ;
25672 int result;
25673 PyObject * obj0 = 0 ;
25674 char *kwnames[] = {
25675 (char *) "winid", NULL
25676 };
25677
25678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25679 {
25680 arg1 = (int)(SWIG_As_int(obj0));
25681 if (SWIG_arg_fail(1)) SWIG_fail;
25682 }
25683 {
25684 PyThreadState* __tstate = wxPyBeginAllowThreads();
25685 result = (int)wxWindow::NextControlId(arg1);
25686
25687 wxPyEndAllowThreads(__tstate);
25688 if (PyErr_Occurred()) SWIG_fail;
25689 }
25690 {
25691 resultobj = SWIG_From_int((int)(result));
25692 }
25693 return resultobj;
25694 fail:
25695 return NULL;
25696 }
25697
25698
25699 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25700 PyObject *resultobj;
25701 int arg1 ;
25702 int result;
25703 PyObject * obj0 = 0 ;
25704 char *kwnames[] = {
25705 (char *) "winid", NULL
25706 };
25707
25708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25709 {
25710 arg1 = (int)(SWIG_As_int(obj0));
25711 if (SWIG_arg_fail(1)) SWIG_fail;
25712 }
25713 {
25714 PyThreadState* __tstate = wxPyBeginAllowThreads();
25715 result = (int)wxWindow::PrevControlId(arg1);
25716
25717 wxPyEndAllowThreads(__tstate);
25718 if (PyErr_Occurred()) SWIG_fail;
25719 }
25720 {
25721 resultobj = SWIG_From_int((int)(result));
25722 }
25723 return resultobj;
25724 fail:
25725 return NULL;
25726 }
25727
25728
25729 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25730 PyObject *resultobj;
25731 wxWindow *arg1 = (wxWindow *) 0 ;
25732 wxSize *arg2 = 0 ;
25733 wxSize temp2 ;
25734 PyObject * obj0 = 0 ;
25735 PyObject * obj1 = 0 ;
25736 char *kwnames[] = {
25737 (char *) "self",(char *) "size", NULL
25738 };
25739
25740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25742 if (SWIG_arg_fail(1)) SWIG_fail;
25743 {
25744 arg2 = &temp2;
25745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25746 }
25747 {
25748 PyThreadState* __tstate = wxPyBeginAllowThreads();
25749 (arg1)->SetSize((wxSize const &)*arg2);
25750
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 Py_INCREF(Py_None); resultobj = Py_None;
25755 return resultobj;
25756 fail:
25757 return NULL;
25758 }
25759
25760
25761 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25762 PyObject *resultobj;
25763 wxWindow *arg1 = (wxWindow *) 0 ;
25764 int arg2 ;
25765 int arg3 ;
25766 int arg4 ;
25767 int arg5 ;
25768 int arg6 = (int) wxSIZE_AUTO ;
25769 PyObject * obj0 = 0 ;
25770 PyObject * obj1 = 0 ;
25771 PyObject * obj2 = 0 ;
25772 PyObject * obj3 = 0 ;
25773 PyObject * obj4 = 0 ;
25774 PyObject * obj5 = 0 ;
25775 char *kwnames[] = {
25776 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25777 };
25778
25779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25781 if (SWIG_arg_fail(1)) SWIG_fail;
25782 {
25783 arg2 = (int)(SWIG_As_int(obj1));
25784 if (SWIG_arg_fail(2)) SWIG_fail;
25785 }
25786 {
25787 arg3 = (int)(SWIG_As_int(obj2));
25788 if (SWIG_arg_fail(3)) SWIG_fail;
25789 }
25790 {
25791 arg4 = (int)(SWIG_As_int(obj3));
25792 if (SWIG_arg_fail(4)) SWIG_fail;
25793 }
25794 {
25795 arg5 = (int)(SWIG_As_int(obj4));
25796 if (SWIG_arg_fail(5)) SWIG_fail;
25797 }
25798 if (obj5) {
25799 {
25800 arg6 = (int)(SWIG_As_int(obj5));
25801 if (SWIG_arg_fail(6)) SWIG_fail;
25802 }
25803 }
25804 {
25805 PyThreadState* __tstate = wxPyBeginAllowThreads();
25806 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25807
25808 wxPyEndAllowThreads(__tstate);
25809 if (PyErr_Occurred()) SWIG_fail;
25810 }
25811 Py_INCREF(Py_None); resultobj = Py_None;
25812 return resultobj;
25813 fail:
25814 return NULL;
25815 }
25816
25817
25818 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25819 PyObject *resultobj;
25820 wxWindow *arg1 = (wxWindow *) 0 ;
25821 wxRect *arg2 = 0 ;
25822 int arg3 = (int) wxSIZE_AUTO ;
25823 wxRect temp2 ;
25824 PyObject * obj0 = 0 ;
25825 PyObject * obj1 = 0 ;
25826 PyObject * obj2 = 0 ;
25827 char *kwnames[] = {
25828 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25829 };
25830
25831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25833 if (SWIG_arg_fail(1)) SWIG_fail;
25834 {
25835 arg2 = &temp2;
25836 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25837 }
25838 if (obj2) {
25839 {
25840 arg3 = (int)(SWIG_As_int(obj2));
25841 if (SWIG_arg_fail(3)) SWIG_fail;
25842 }
25843 }
25844 {
25845 PyThreadState* __tstate = wxPyBeginAllowThreads();
25846 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25847
25848 wxPyEndAllowThreads(__tstate);
25849 if (PyErr_Occurred()) SWIG_fail;
25850 }
25851 Py_INCREF(Py_None); resultobj = Py_None;
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj;
25860 wxWindow *arg1 = (wxWindow *) 0 ;
25861 int arg2 ;
25862 int arg3 ;
25863 PyObject * obj0 = 0 ;
25864 PyObject * obj1 = 0 ;
25865 PyObject * obj2 = 0 ;
25866 char *kwnames[] = {
25867 (char *) "self",(char *) "width",(char *) "height", NULL
25868 };
25869
25870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25872 if (SWIG_arg_fail(1)) SWIG_fail;
25873 {
25874 arg2 = (int)(SWIG_As_int(obj1));
25875 if (SWIG_arg_fail(2)) SWIG_fail;
25876 }
25877 {
25878 arg3 = (int)(SWIG_As_int(obj2));
25879 if (SWIG_arg_fail(3)) SWIG_fail;
25880 }
25881 {
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 (arg1)->SetSize(arg2,arg3);
25884
25885 wxPyEndAllowThreads(__tstate);
25886 if (PyErr_Occurred()) SWIG_fail;
25887 }
25888 Py_INCREF(Py_None); resultobj = Py_None;
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj;
25897 wxWindow *arg1 = (wxWindow *) 0 ;
25898 wxPoint *arg2 = 0 ;
25899 int arg3 = (int) wxSIZE_USE_EXISTING ;
25900 wxPoint temp2 ;
25901 PyObject * obj0 = 0 ;
25902 PyObject * obj1 = 0 ;
25903 PyObject * obj2 = 0 ;
25904 char *kwnames[] = {
25905 (char *) "self",(char *) "pt",(char *) "flags", NULL
25906 };
25907
25908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25910 if (SWIG_arg_fail(1)) SWIG_fail;
25911 {
25912 arg2 = &temp2;
25913 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25914 }
25915 if (obj2) {
25916 {
25917 arg3 = (int)(SWIG_As_int(obj2));
25918 if (SWIG_arg_fail(3)) SWIG_fail;
25919 }
25920 }
25921 {
25922 PyThreadState* __tstate = wxPyBeginAllowThreads();
25923 (arg1)->Move((wxPoint const &)*arg2,arg3);
25924
25925 wxPyEndAllowThreads(__tstate);
25926 if (PyErr_Occurred()) SWIG_fail;
25927 }
25928 Py_INCREF(Py_None); resultobj = Py_None;
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25936 PyObject *resultobj;
25937 wxWindow *arg1 = (wxWindow *) 0 ;
25938 int arg2 ;
25939 int arg3 ;
25940 int arg4 = (int) wxSIZE_USE_EXISTING ;
25941 PyObject * obj0 = 0 ;
25942 PyObject * obj1 = 0 ;
25943 PyObject * obj2 = 0 ;
25944 PyObject * obj3 = 0 ;
25945 char *kwnames[] = {
25946 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25947 };
25948
25949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25951 if (SWIG_arg_fail(1)) SWIG_fail;
25952 {
25953 arg2 = (int)(SWIG_As_int(obj1));
25954 if (SWIG_arg_fail(2)) SWIG_fail;
25955 }
25956 {
25957 arg3 = (int)(SWIG_As_int(obj2));
25958 if (SWIG_arg_fail(3)) SWIG_fail;
25959 }
25960 if (obj3) {
25961 {
25962 arg4 = (int)(SWIG_As_int(obj3));
25963 if (SWIG_arg_fail(4)) SWIG_fail;
25964 }
25965 }
25966 {
25967 PyThreadState* __tstate = wxPyBeginAllowThreads();
25968 (arg1)->Move(arg2,arg3,arg4);
25969
25970 wxPyEndAllowThreads(__tstate);
25971 if (PyErr_Occurred()) SWIG_fail;
25972 }
25973 Py_INCREF(Py_None); resultobj = Py_None;
25974 return resultobj;
25975 fail:
25976 return NULL;
25977 }
25978
25979
25980 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25981 PyObject *resultobj;
25982 wxWindow *arg1 = (wxWindow *) 0 ;
25983 wxSize const &arg2_defvalue = wxDefaultSize ;
25984 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25985 wxSize temp2 ;
25986 PyObject * obj0 = 0 ;
25987 PyObject * obj1 = 0 ;
25988 char *kwnames[] = {
25989 (char *) "self",(char *) "size", NULL
25990 };
25991
25992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25994 if (SWIG_arg_fail(1)) SWIG_fail;
25995 if (obj1) {
25996 {
25997 arg2 = &temp2;
25998 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25999 }
26000 }
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26004
26005 wxPyEndAllowThreads(__tstate);
26006 if (PyErr_Occurred()) SWIG_fail;
26007 }
26008 Py_INCREF(Py_None); resultobj = Py_None;
26009 return resultobj;
26010 fail:
26011 return NULL;
26012 }
26013
26014
26015 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26016 PyObject *resultobj;
26017 wxWindow *arg1 = (wxWindow *) 0 ;
26018 PyObject * obj0 = 0 ;
26019 char *kwnames[] = {
26020 (char *) "self", NULL
26021 };
26022
26023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26025 if (SWIG_arg_fail(1)) SWIG_fail;
26026 {
26027 PyThreadState* __tstate = wxPyBeginAllowThreads();
26028 (arg1)->Raise();
26029
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 Py_INCREF(Py_None); resultobj = Py_None;
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26041 PyObject *resultobj;
26042 wxWindow *arg1 = (wxWindow *) 0 ;
26043 PyObject * obj0 = 0 ;
26044 char *kwnames[] = {
26045 (char *) "self", NULL
26046 };
26047
26048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26050 if (SWIG_arg_fail(1)) SWIG_fail;
26051 {
26052 PyThreadState* __tstate = wxPyBeginAllowThreads();
26053 (arg1)->Lower();
26054
26055 wxPyEndAllowThreads(__tstate);
26056 if (PyErr_Occurred()) SWIG_fail;
26057 }
26058 Py_INCREF(Py_None); resultobj = Py_None;
26059 return resultobj;
26060 fail:
26061 return NULL;
26062 }
26063
26064
26065 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26066 PyObject *resultobj;
26067 wxWindow *arg1 = (wxWindow *) 0 ;
26068 wxSize *arg2 = 0 ;
26069 wxSize temp2 ;
26070 PyObject * obj0 = 0 ;
26071 PyObject * obj1 = 0 ;
26072 char *kwnames[] = {
26073 (char *) "self",(char *) "size", NULL
26074 };
26075
26076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26078 if (SWIG_arg_fail(1)) SWIG_fail;
26079 {
26080 arg2 = &temp2;
26081 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26082 }
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 (arg1)->SetClientSize((wxSize const &)*arg2);
26086
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 Py_INCREF(Py_None); resultobj = Py_None;
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj;
26099 wxWindow *arg1 = (wxWindow *) 0 ;
26100 int arg2 ;
26101 int arg3 ;
26102 PyObject * obj0 = 0 ;
26103 PyObject * obj1 = 0 ;
26104 PyObject * obj2 = 0 ;
26105 char *kwnames[] = {
26106 (char *) "self",(char *) "width",(char *) "height", NULL
26107 };
26108
26109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26111 if (SWIG_arg_fail(1)) SWIG_fail;
26112 {
26113 arg2 = (int)(SWIG_As_int(obj1));
26114 if (SWIG_arg_fail(2)) SWIG_fail;
26115 }
26116 {
26117 arg3 = (int)(SWIG_As_int(obj2));
26118 if (SWIG_arg_fail(3)) SWIG_fail;
26119 }
26120 {
26121 PyThreadState* __tstate = wxPyBeginAllowThreads();
26122 (arg1)->SetClientSize(arg2,arg3);
26123
26124 wxPyEndAllowThreads(__tstate);
26125 if (PyErr_Occurred()) SWIG_fail;
26126 }
26127 Py_INCREF(Py_None); resultobj = Py_None;
26128 return resultobj;
26129 fail:
26130 return NULL;
26131 }
26132
26133
26134 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26135 PyObject *resultobj;
26136 wxWindow *arg1 = (wxWindow *) 0 ;
26137 wxRect *arg2 = 0 ;
26138 wxRect temp2 ;
26139 PyObject * obj0 = 0 ;
26140 PyObject * obj1 = 0 ;
26141 char *kwnames[] = {
26142 (char *) "self",(char *) "rect", NULL
26143 };
26144
26145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26147 if (SWIG_arg_fail(1)) SWIG_fail;
26148 {
26149 arg2 = &temp2;
26150 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26151 }
26152 {
26153 PyThreadState* __tstate = wxPyBeginAllowThreads();
26154 (arg1)->SetClientSize((wxRect const &)*arg2);
26155
26156 wxPyEndAllowThreads(__tstate);
26157 if (PyErr_Occurred()) SWIG_fail;
26158 }
26159 Py_INCREF(Py_None); resultobj = Py_None;
26160 return resultobj;
26161 fail:
26162 return NULL;
26163 }
26164
26165
26166 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26167 PyObject *resultobj;
26168 wxWindow *arg1 = (wxWindow *) 0 ;
26169 wxPoint result;
26170 PyObject * obj0 = 0 ;
26171 char *kwnames[] = {
26172 (char *) "self", NULL
26173 };
26174
26175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26177 if (SWIG_arg_fail(1)) SWIG_fail;
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 result = (arg1)->GetPosition();
26181
26182 wxPyEndAllowThreads(__tstate);
26183 if (PyErr_Occurred()) SWIG_fail;
26184 }
26185 {
26186 wxPoint * resultptr;
26187 resultptr = new wxPoint((wxPoint &)(result));
26188 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26189 }
26190 return resultobj;
26191 fail:
26192 return NULL;
26193 }
26194
26195
26196 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26197 PyObject *resultobj;
26198 wxWindow *arg1 = (wxWindow *) 0 ;
26199 int *arg2 = (int *) 0 ;
26200 int *arg3 = (int *) 0 ;
26201 int temp2 ;
26202 int res2 = 0 ;
26203 int temp3 ;
26204 int res3 = 0 ;
26205 PyObject * obj0 = 0 ;
26206 char *kwnames[] = {
26207 (char *) "self", NULL
26208 };
26209
26210 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26211 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26214 if (SWIG_arg_fail(1)) SWIG_fail;
26215 {
26216 PyThreadState* __tstate = wxPyBeginAllowThreads();
26217 (arg1)->GetPosition(arg2,arg3);
26218
26219 wxPyEndAllowThreads(__tstate);
26220 if (PyErr_Occurred()) SWIG_fail;
26221 }
26222 Py_INCREF(Py_None); resultobj = Py_None;
26223 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26224 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26225 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26226 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26227 return resultobj;
26228 fail:
26229 return NULL;
26230 }
26231
26232
26233 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26234 PyObject *resultobj;
26235 wxWindow *arg1 = (wxWindow *) 0 ;
26236 wxSize result;
26237 PyObject * obj0 = 0 ;
26238 char *kwnames[] = {
26239 (char *) "self", NULL
26240 };
26241
26242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26244 if (SWIG_arg_fail(1)) SWIG_fail;
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 result = ((wxWindow const *)arg1)->GetSize();
26248
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 {
26253 wxSize * resultptr;
26254 resultptr = new wxSize((wxSize &)(result));
26255 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26256 }
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26264 PyObject *resultobj;
26265 wxWindow *arg1 = (wxWindow *) 0 ;
26266 int *arg2 = (int *) 0 ;
26267 int *arg3 = (int *) 0 ;
26268 int temp2 ;
26269 int res2 = 0 ;
26270 int temp3 ;
26271 int res3 = 0 ;
26272 PyObject * obj0 = 0 ;
26273 char *kwnames[] = {
26274 (char *) "self", NULL
26275 };
26276
26277 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26278 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26281 if (SWIG_arg_fail(1)) SWIG_fail;
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26285
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 Py_INCREF(Py_None); resultobj = Py_None;
26290 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26291 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26292 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26293 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26294 return resultobj;
26295 fail:
26296 return NULL;
26297 }
26298
26299
26300 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26301 PyObject *resultobj;
26302 wxWindow *arg1 = (wxWindow *) 0 ;
26303 wxRect result;
26304 PyObject * obj0 = 0 ;
26305 char *kwnames[] = {
26306 (char *) "self", NULL
26307 };
26308
26309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26311 if (SWIG_arg_fail(1)) SWIG_fail;
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 result = ((wxWindow const *)arg1)->GetRect();
26315
26316 wxPyEndAllowThreads(__tstate);
26317 if (PyErr_Occurred()) SWIG_fail;
26318 }
26319 {
26320 wxRect * resultptr;
26321 resultptr = new wxRect((wxRect &)(result));
26322 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26323 }
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26331 PyObject *resultobj;
26332 wxWindow *arg1 = (wxWindow *) 0 ;
26333 wxSize result;
26334 PyObject * obj0 = 0 ;
26335 char *kwnames[] = {
26336 (char *) "self", NULL
26337 };
26338
26339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26341 if (SWIG_arg_fail(1)) SWIG_fail;
26342 {
26343 PyThreadState* __tstate = wxPyBeginAllowThreads();
26344 result = ((wxWindow const *)arg1)->GetClientSize();
26345
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 {
26350 wxSize * resultptr;
26351 resultptr = new wxSize((wxSize &)(result));
26352 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26353 }
26354 return resultobj;
26355 fail:
26356 return NULL;
26357 }
26358
26359
26360 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26361 PyObject *resultobj;
26362 wxWindow *arg1 = (wxWindow *) 0 ;
26363 int *arg2 = (int *) 0 ;
26364 int *arg3 = (int *) 0 ;
26365 int temp2 ;
26366 int res2 = 0 ;
26367 int temp3 ;
26368 int res3 = 0 ;
26369 PyObject * obj0 = 0 ;
26370 char *kwnames[] = {
26371 (char *) "self", NULL
26372 };
26373
26374 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26375 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26378 if (SWIG_arg_fail(1)) SWIG_fail;
26379 {
26380 PyThreadState* __tstate = wxPyBeginAllowThreads();
26381 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26382
26383 wxPyEndAllowThreads(__tstate);
26384 if (PyErr_Occurred()) SWIG_fail;
26385 }
26386 Py_INCREF(Py_None); resultobj = Py_None;
26387 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26388 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26389 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26390 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26391 return resultobj;
26392 fail:
26393 return NULL;
26394 }
26395
26396
26397 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26398 PyObject *resultobj;
26399 wxWindow *arg1 = (wxWindow *) 0 ;
26400 wxPoint result;
26401 PyObject * obj0 = 0 ;
26402 char *kwnames[] = {
26403 (char *) "self", NULL
26404 };
26405
26406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26408 if (SWIG_arg_fail(1)) SWIG_fail;
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26412
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 {
26417 wxPoint * resultptr;
26418 resultptr = new wxPoint((wxPoint &)(result));
26419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26420 }
26421 return resultobj;
26422 fail:
26423 return NULL;
26424 }
26425
26426
26427 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26428 PyObject *resultobj;
26429 wxWindow *arg1 = (wxWindow *) 0 ;
26430 wxRect result;
26431 PyObject * obj0 = 0 ;
26432 char *kwnames[] = {
26433 (char *) "self", NULL
26434 };
26435
26436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26438 if (SWIG_arg_fail(1)) SWIG_fail;
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = ((wxWindow const *)arg1)->GetClientRect();
26442
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 {
26447 wxRect * resultptr;
26448 resultptr = new wxRect((wxRect &)(result));
26449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26450 }
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 wxSize result;
26461 PyObject * obj0 = 0 ;
26462 char *kwnames[] = {
26463 (char *) "self", NULL
26464 };
26465
26466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26468 if (SWIG_arg_fail(1)) SWIG_fail;
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 result = ((wxWindow const *)arg1)->GetBestSize();
26472
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 {
26477 wxSize * resultptr;
26478 resultptr = new wxSize((wxSize &)(result));
26479 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26480 }
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26488 PyObject *resultobj;
26489 wxWindow *arg1 = (wxWindow *) 0 ;
26490 int *arg2 = (int *) 0 ;
26491 int *arg3 = (int *) 0 ;
26492 int temp2 ;
26493 int res2 = 0 ;
26494 int temp3 ;
26495 int res3 = 0 ;
26496 PyObject * obj0 = 0 ;
26497 char *kwnames[] = {
26498 (char *) "self", NULL
26499 };
26500
26501 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26502 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26505 if (SWIG_arg_fail(1)) SWIG_fail;
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26509
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 Py_INCREF(Py_None); resultobj = Py_None;
26514 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26515 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26516 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26517 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26525 PyObject *resultobj;
26526 wxWindow *arg1 = (wxWindow *) 0 ;
26527 PyObject * obj0 = 0 ;
26528 char *kwnames[] = {
26529 (char *) "self", NULL
26530 };
26531
26532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26534 if (SWIG_arg_fail(1)) SWIG_fail;
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 (arg1)->InvalidateBestSize();
26538
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 Py_INCREF(Py_None); resultobj = Py_None;
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26550 PyObject *resultobj;
26551 wxWindow *arg1 = (wxWindow *) 0 ;
26552 wxSize *arg2 = 0 ;
26553 wxSize temp2 ;
26554 PyObject * obj0 = 0 ;
26555 PyObject * obj1 = 0 ;
26556 char *kwnames[] = {
26557 (char *) "self",(char *) "size", NULL
26558 };
26559
26560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
26561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26562 if (SWIG_arg_fail(1)) SWIG_fail;
26563 {
26564 arg2 = &temp2;
26565 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26566 }
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
26570
26571 wxPyEndAllowThreads(__tstate);
26572 if (PyErr_Occurred()) SWIG_fail;
26573 }
26574 Py_INCREF(Py_None); resultobj = Py_None;
26575 return resultobj;
26576 fail:
26577 return NULL;
26578 }
26579
26580
26581 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26582 PyObject *resultobj;
26583 wxWindow *arg1 = (wxWindow *) 0 ;
26584 wxSize result;
26585 PyObject * obj0 = 0 ;
26586 char *kwnames[] = {
26587 (char *) "self", NULL
26588 };
26589
26590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26592 if (SWIG_arg_fail(1)) SWIG_fail;
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26596
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 {
26601 wxSize * resultptr;
26602 resultptr = new wxSize((wxSize &)(result));
26603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26604 }
26605 return resultobj;
26606 fail:
26607 return NULL;
26608 }
26609
26610
26611 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26612 PyObject *resultobj;
26613 wxWindow *arg1 = (wxWindow *) 0 ;
26614 wxSize result;
26615 PyObject * obj0 = 0 ;
26616 char *kwnames[] = {
26617 (char *) "self", NULL
26618 };
26619
26620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26622 if (SWIG_arg_fail(1)) SWIG_fail;
26623 {
26624 PyThreadState* __tstate = wxPyBeginAllowThreads();
26625 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26626
26627 wxPyEndAllowThreads(__tstate);
26628 if (PyErr_Occurred()) SWIG_fail;
26629 }
26630 {
26631 wxSize * resultptr;
26632 resultptr = new wxSize((wxSize &)(result));
26633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26634 }
26635 return resultobj;
26636 fail:
26637 return NULL;
26638 }
26639
26640
26641 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26642 PyObject *resultobj;
26643 wxWindow *arg1 = (wxWindow *) 0 ;
26644 int arg2 = (int) wxBOTH ;
26645 PyObject * obj0 = 0 ;
26646 PyObject * obj1 = 0 ;
26647 char *kwnames[] = {
26648 (char *) "self",(char *) "direction", NULL
26649 };
26650
26651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26653 if (SWIG_arg_fail(1)) SWIG_fail;
26654 if (obj1) {
26655 {
26656 arg2 = (int)(SWIG_As_int(obj1));
26657 if (SWIG_arg_fail(2)) SWIG_fail;
26658 }
26659 }
26660 {
26661 PyThreadState* __tstate = wxPyBeginAllowThreads();
26662 (arg1)->Center(arg2);
26663
26664 wxPyEndAllowThreads(__tstate);
26665 if (PyErr_Occurred()) SWIG_fail;
26666 }
26667 Py_INCREF(Py_None); resultobj = Py_None;
26668 return resultobj;
26669 fail:
26670 return NULL;
26671 }
26672
26673
26674 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26675 PyObject *resultobj;
26676 wxWindow *arg1 = (wxWindow *) 0 ;
26677 int arg2 = (int) wxBOTH ;
26678 PyObject * obj0 = 0 ;
26679 PyObject * obj1 = 0 ;
26680 char *kwnames[] = {
26681 (char *) "self",(char *) "dir", NULL
26682 };
26683
26684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26686 if (SWIG_arg_fail(1)) SWIG_fail;
26687 if (obj1) {
26688 {
26689 arg2 = (int)(SWIG_As_int(obj1));
26690 if (SWIG_arg_fail(2)) SWIG_fail;
26691 }
26692 }
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 (arg1)->CenterOnScreen(arg2);
26696
26697 wxPyEndAllowThreads(__tstate);
26698 if (PyErr_Occurred()) SWIG_fail;
26699 }
26700 Py_INCREF(Py_None); resultobj = Py_None;
26701 return resultobj;
26702 fail:
26703 return NULL;
26704 }
26705
26706
26707 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26708 PyObject *resultobj;
26709 wxWindow *arg1 = (wxWindow *) 0 ;
26710 int arg2 = (int) wxBOTH ;
26711 PyObject * obj0 = 0 ;
26712 PyObject * obj1 = 0 ;
26713 char *kwnames[] = {
26714 (char *) "self",(char *) "dir", NULL
26715 };
26716
26717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26719 if (SWIG_arg_fail(1)) SWIG_fail;
26720 if (obj1) {
26721 {
26722 arg2 = (int)(SWIG_As_int(obj1));
26723 if (SWIG_arg_fail(2)) SWIG_fail;
26724 }
26725 }
26726 {
26727 PyThreadState* __tstate = wxPyBeginAllowThreads();
26728 (arg1)->CenterOnParent(arg2);
26729
26730 wxPyEndAllowThreads(__tstate);
26731 if (PyErr_Occurred()) SWIG_fail;
26732 }
26733 Py_INCREF(Py_None); resultobj = Py_None;
26734 return resultobj;
26735 fail:
26736 return NULL;
26737 }
26738
26739
26740 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26741 PyObject *resultobj;
26742 wxWindow *arg1 = (wxWindow *) 0 ;
26743 PyObject * obj0 = 0 ;
26744 char *kwnames[] = {
26745 (char *) "self", NULL
26746 };
26747
26748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26750 if (SWIG_arg_fail(1)) SWIG_fail;
26751 {
26752 PyThreadState* __tstate = wxPyBeginAllowThreads();
26753 (arg1)->Fit();
26754
26755 wxPyEndAllowThreads(__tstate);
26756 if (PyErr_Occurred()) SWIG_fail;
26757 }
26758 Py_INCREF(Py_None); resultobj = Py_None;
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj;
26767 wxWindow *arg1 = (wxWindow *) 0 ;
26768 PyObject * obj0 = 0 ;
26769 char *kwnames[] = {
26770 (char *) "self", NULL
26771 };
26772
26773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26775 if (SWIG_arg_fail(1)) SWIG_fail;
26776 {
26777 PyThreadState* __tstate = wxPyBeginAllowThreads();
26778 (arg1)->FitInside();
26779
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 Py_INCREF(Py_None); resultobj = Py_None;
26784 return resultobj;
26785 fail:
26786 return NULL;
26787 }
26788
26789
26790 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26791 PyObject *resultobj;
26792 wxWindow *arg1 = (wxWindow *) 0 ;
26793 int arg2 ;
26794 int arg3 ;
26795 int arg4 = (int) -1 ;
26796 int arg5 = (int) -1 ;
26797 int arg6 = (int) -1 ;
26798 int arg7 = (int) -1 ;
26799 PyObject * obj0 = 0 ;
26800 PyObject * obj1 = 0 ;
26801 PyObject * obj2 = 0 ;
26802 PyObject * obj3 = 0 ;
26803 PyObject * obj4 = 0 ;
26804 PyObject * obj5 = 0 ;
26805 PyObject * obj6 = 0 ;
26806 char *kwnames[] = {
26807 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26808 };
26809
26810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26812 if (SWIG_arg_fail(1)) SWIG_fail;
26813 {
26814 arg2 = (int)(SWIG_As_int(obj1));
26815 if (SWIG_arg_fail(2)) SWIG_fail;
26816 }
26817 {
26818 arg3 = (int)(SWIG_As_int(obj2));
26819 if (SWIG_arg_fail(3)) SWIG_fail;
26820 }
26821 if (obj3) {
26822 {
26823 arg4 = (int)(SWIG_As_int(obj3));
26824 if (SWIG_arg_fail(4)) SWIG_fail;
26825 }
26826 }
26827 if (obj4) {
26828 {
26829 arg5 = (int)(SWIG_As_int(obj4));
26830 if (SWIG_arg_fail(5)) SWIG_fail;
26831 }
26832 }
26833 if (obj5) {
26834 {
26835 arg6 = (int)(SWIG_As_int(obj5));
26836 if (SWIG_arg_fail(6)) SWIG_fail;
26837 }
26838 }
26839 if (obj6) {
26840 {
26841 arg7 = (int)(SWIG_As_int(obj6));
26842 if (SWIG_arg_fail(7)) SWIG_fail;
26843 }
26844 }
26845 {
26846 PyThreadState* __tstate = wxPyBeginAllowThreads();
26847 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26848
26849 wxPyEndAllowThreads(__tstate);
26850 if (PyErr_Occurred()) SWIG_fail;
26851 }
26852 Py_INCREF(Py_None); resultobj = Py_None;
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj;
26861 wxWindow *arg1 = (wxWindow *) 0 ;
26862 wxSize *arg2 = 0 ;
26863 wxSize const &arg3_defvalue = wxDefaultSize ;
26864 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26865 wxSize const &arg4_defvalue = wxDefaultSize ;
26866 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26867 wxSize temp2 ;
26868 wxSize temp3 ;
26869 wxSize temp4 ;
26870 PyObject * obj0 = 0 ;
26871 PyObject * obj1 = 0 ;
26872 PyObject * obj2 = 0 ;
26873 PyObject * obj3 = 0 ;
26874 char *kwnames[] = {
26875 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26876 };
26877
26878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26880 if (SWIG_arg_fail(1)) SWIG_fail;
26881 {
26882 arg2 = &temp2;
26883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26884 }
26885 if (obj2) {
26886 {
26887 arg3 = &temp3;
26888 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26889 }
26890 }
26891 if (obj3) {
26892 {
26893 arg4 = &temp4;
26894 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26895 }
26896 }
26897 {
26898 PyThreadState* __tstate = wxPyBeginAllowThreads();
26899 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26900
26901 wxPyEndAllowThreads(__tstate);
26902 if (PyErr_Occurred()) SWIG_fail;
26903 }
26904 Py_INCREF(Py_None); resultobj = Py_None;
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj;
26913 wxWindow *arg1 = (wxWindow *) 0 ;
26914 int arg2 ;
26915 int arg3 ;
26916 int arg4 = (int) -1 ;
26917 int arg5 = (int) -1 ;
26918 PyObject * obj0 = 0 ;
26919 PyObject * obj1 = 0 ;
26920 PyObject * obj2 = 0 ;
26921 PyObject * obj3 = 0 ;
26922 PyObject * obj4 = 0 ;
26923 char *kwnames[] = {
26924 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26925 };
26926
26927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26929 if (SWIG_arg_fail(1)) SWIG_fail;
26930 {
26931 arg2 = (int)(SWIG_As_int(obj1));
26932 if (SWIG_arg_fail(2)) SWIG_fail;
26933 }
26934 {
26935 arg3 = (int)(SWIG_As_int(obj2));
26936 if (SWIG_arg_fail(3)) SWIG_fail;
26937 }
26938 if (obj3) {
26939 {
26940 arg4 = (int)(SWIG_As_int(obj3));
26941 if (SWIG_arg_fail(4)) SWIG_fail;
26942 }
26943 }
26944 if (obj4) {
26945 {
26946 arg5 = (int)(SWIG_As_int(obj4));
26947 if (SWIG_arg_fail(5)) SWIG_fail;
26948 }
26949 }
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26953
26954 wxPyEndAllowThreads(__tstate);
26955 if (PyErr_Occurred()) SWIG_fail;
26956 }
26957 Py_INCREF(Py_None); resultobj = Py_None;
26958 return resultobj;
26959 fail:
26960 return NULL;
26961 }
26962
26963
26964 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26965 PyObject *resultobj;
26966 wxWindow *arg1 = (wxWindow *) 0 ;
26967 wxSize *arg2 = 0 ;
26968 wxSize const &arg3_defvalue = wxDefaultSize ;
26969 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26970 wxSize temp2 ;
26971 wxSize temp3 ;
26972 PyObject * obj0 = 0 ;
26973 PyObject * obj1 = 0 ;
26974 PyObject * obj2 = 0 ;
26975 char *kwnames[] = {
26976 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26977 };
26978
26979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26981 if (SWIG_arg_fail(1)) SWIG_fail;
26982 {
26983 arg2 = &temp2;
26984 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26985 }
26986 if (obj2) {
26987 {
26988 arg3 = &temp3;
26989 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26990 }
26991 }
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26995
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 Py_INCREF(Py_None); resultobj = Py_None;
27000 return resultobj;
27001 fail:
27002 return NULL;
27003 }
27004
27005
27006 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27007 PyObject *resultobj;
27008 wxWindow *arg1 = (wxWindow *) 0 ;
27009 wxSize result;
27010 PyObject * obj0 = 0 ;
27011 char *kwnames[] = {
27012 (char *) "self", NULL
27013 };
27014
27015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27017 if (SWIG_arg_fail(1)) SWIG_fail;
27018 {
27019 PyThreadState* __tstate = wxPyBeginAllowThreads();
27020 result = ((wxWindow const *)arg1)->GetMaxSize();
27021
27022 wxPyEndAllowThreads(__tstate);
27023 if (PyErr_Occurred()) SWIG_fail;
27024 }
27025 {
27026 wxSize * resultptr;
27027 resultptr = new wxSize((wxSize &)(result));
27028 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27029 }
27030 return resultobj;
27031 fail:
27032 return NULL;
27033 }
27034
27035
27036 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27037 PyObject *resultobj;
27038 wxWindow *arg1 = (wxWindow *) 0 ;
27039 wxSize result;
27040 PyObject * obj0 = 0 ;
27041 char *kwnames[] = {
27042 (char *) "self", NULL
27043 };
27044
27045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27047 if (SWIG_arg_fail(1)) SWIG_fail;
27048 {
27049 PyThreadState* __tstate = wxPyBeginAllowThreads();
27050 result = ((wxWindow const *)arg1)->GetMinSize();
27051
27052 wxPyEndAllowThreads(__tstate);
27053 if (PyErr_Occurred()) SWIG_fail;
27054 }
27055 {
27056 wxSize * resultptr;
27057 resultptr = new wxSize((wxSize &)(result));
27058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27059 }
27060 return resultobj;
27061 fail:
27062 return NULL;
27063 }
27064
27065
27066 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27067 PyObject *resultobj;
27068 wxWindow *arg1 = (wxWindow *) 0 ;
27069 wxSize *arg2 = 0 ;
27070 wxSize temp2 ;
27071 PyObject * obj0 = 0 ;
27072 PyObject * obj1 = 0 ;
27073 char *kwnames[] = {
27074 (char *) "self",(char *) "minSize", NULL
27075 };
27076
27077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27079 if (SWIG_arg_fail(1)) SWIG_fail;
27080 {
27081 arg2 = &temp2;
27082 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27083 }
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 (arg1)->SetMinSize((wxSize const &)*arg2);
27087
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 Py_INCREF(Py_None); resultobj = Py_None;
27092 return resultobj;
27093 fail:
27094 return NULL;
27095 }
27096
27097
27098 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27099 PyObject *resultobj;
27100 wxWindow *arg1 = (wxWindow *) 0 ;
27101 wxSize *arg2 = 0 ;
27102 wxSize temp2 ;
27103 PyObject * obj0 = 0 ;
27104 PyObject * obj1 = 0 ;
27105 char *kwnames[] = {
27106 (char *) "self",(char *) "maxSize", NULL
27107 };
27108
27109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27111 if (SWIG_arg_fail(1)) SWIG_fail;
27112 {
27113 arg2 = &temp2;
27114 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27115 }
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 (arg1)->SetMaxSize((wxSize const &)*arg2);
27119
27120 wxPyEndAllowThreads(__tstate);
27121 if (PyErr_Occurred()) SWIG_fail;
27122 }
27123 Py_INCREF(Py_None); resultobj = Py_None;
27124 return resultobj;
27125 fail:
27126 return NULL;
27127 }
27128
27129
27130 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27131 PyObject *resultobj;
27132 wxWindow *arg1 = (wxWindow *) 0 ;
27133 int result;
27134 PyObject * obj0 = 0 ;
27135 char *kwnames[] = {
27136 (char *) "self", NULL
27137 };
27138
27139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27141 if (SWIG_arg_fail(1)) SWIG_fail;
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27145
27146 wxPyEndAllowThreads(__tstate);
27147 if (PyErr_Occurred()) SWIG_fail;
27148 }
27149 {
27150 resultobj = SWIG_From_int((int)(result));
27151 }
27152 return resultobj;
27153 fail:
27154 return NULL;
27155 }
27156
27157
27158 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27159 PyObject *resultobj;
27160 wxWindow *arg1 = (wxWindow *) 0 ;
27161 int result;
27162 PyObject * obj0 = 0 ;
27163 char *kwnames[] = {
27164 (char *) "self", NULL
27165 };
27166
27167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27169 if (SWIG_arg_fail(1)) SWIG_fail;
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27173
27174 wxPyEndAllowThreads(__tstate);
27175 if (PyErr_Occurred()) SWIG_fail;
27176 }
27177 {
27178 resultobj = SWIG_From_int((int)(result));
27179 }
27180 return resultobj;
27181 fail:
27182 return NULL;
27183 }
27184
27185
27186 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27187 PyObject *resultobj;
27188 wxWindow *arg1 = (wxWindow *) 0 ;
27189 int result;
27190 PyObject * obj0 = 0 ;
27191 char *kwnames[] = {
27192 (char *) "self", NULL
27193 };
27194
27195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27197 if (SWIG_arg_fail(1)) SWIG_fail;
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27201
27202 wxPyEndAllowThreads(__tstate);
27203 if (PyErr_Occurred()) SWIG_fail;
27204 }
27205 {
27206 resultobj = SWIG_From_int((int)(result));
27207 }
27208 return resultobj;
27209 fail:
27210 return NULL;
27211 }
27212
27213
27214 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27215 PyObject *resultobj;
27216 wxWindow *arg1 = (wxWindow *) 0 ;
27217 int result;
27218 PyObject * obj0 = 0 ;
27219 char *kwnames[] = {
27220 (char *) "self", NULL
27221 };
27222
27223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27225 if (SWIG_arg_fail(1)) SWIG_fail;
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27229
27230 wxPyEndAllowThreads(__tstate);
27231 if (PyErr_Occurred()) SWIG_fail;
27232 }
27233 {
27234 resultobj = SWIG_From_int((int)(result));
27235 }
27236 return resultobj;
27237 fail:
27238 return NULL;
27239 }
27240
27241
27242 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27243 PyObject *resultobj;
27244 wxWindow *arg1 = (wxWindow *) 0 ;
27245 wxSize *arg2 = 0 ;
27246 wxSize temp2 ;
27247 PyObject * obj0 = 0 ;
27248 PyObject * obj1 = 0 ;
27249 char *kwnames[] = {
27250 (char *) "self",(char *) "size", NULL
27251 };
27252
27253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27255 if (SWIG_arg_fail(1)) SWIG_fail;
27256 {
27257 arg2 = &temp2;
27258 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27259 }
27260 {
27261 PyThreadState* __tstate = wxPyBeginAllowThreads();
27262 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27263
27264 wxPyEndAllowThreads(__tstate);
27265 if (PyErr_Occurred()) SWIG_fail;
27266 }
27267 Py_INCREF(Py_None); resultobj = Py_None;
27268 return resultobj;
27269 fail:
27270 return NULL;
27271 }
27272
27273
27274 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27275 PyObject *resultobj;
27276 wxWindow *arg1 = (wxWindow *) 0 ;
27277 int arg2 ;
27278 int arg3 ;
27279 PyObject * obj0 = 0 ;
27280 PyObject * obj1 = 0 ;
27281 PyObject * obj2 = 0 ;
27282 char *kwnames[] = {
27283 (char *) "self",(char *) "w",(char *) "h", NULL
27284 };
27285
27286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27288 if (SWIG_arg_fail(1)) SWIG_fail;
27289 {
27290 arg2 = (int)(SWIG_As_int(obj1));
27291 if (SWIG_arg_fail(2)) SWIG_fail;
27292 }
27293 {
27294 arg3 = (int)(SWIG_As_int(obj2));
27295 if (SWIG_arg_fail(3)) SWIG_fail;
27296 }
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 (arg1)->SetVirtualSize(arg2,arg3);
27300
27301 wxPyEndAllowThreads(__tstate);
27302 if (PyErr_Occurred()) SWIG_fail;
27303 }
27304 Py_INCREF(Py_None); resultobj = Py_None;
27305 return resultobj;
27306 fail:
27307 return NULL;
27308 }
27309
27310
27311 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27312 PyObject *resultobj;
27313 wxWindow *arg1 = (wxWindow *) 0 ;
27314 wxSize result;
27315 PyObject * obj0 = 0 ;
27316 char *kwnames[] = {
27317 (char *) "self", NULL
27318 };
27319
27320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27322 if (SWIG_arg_fail(1)) SWIG_fail;
27323 {
27324 PyThreadState* __tstate = wxPyBeginAllowThreads();
27325 result = ((wxWindow const *)arg1)->GetVirtualSize();
27326
27327 wxPyEndAllowThreads(__tstate);
27328 if (PyErr_Occurred()) SWIG_fail;
27329 }
27330 {
27331 wxSize * resultptr;
27332 resultptr = new wxSize((wxSize &)(result));
27333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27334 }
27335 return resultobj;
27336 fail:
27337 return NULL;
27338 }
27339
27340
27341 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27342 PyObject *resultobj;
27343 wxWindow *arg1 = (wxWindow *) 0 ;
27344 int *arg2 = (int *) 0 ;
27345 int *arg3 = (int *) 0 ;
27346 int temp2 ;
27347 int res2 = 0 ;
27348 int temp3 ;
27349 int res3 = 0 ;
27350 PyObject * obj0 = 0 ;
27351 char *kwnames[] = {
27352 (char *) "self", NULL
27353 };
27354
27355 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27356 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27359 if (SWIG_arg_fail(1)) SWIG_fail;
27360 {
27361 PyThreadState* __tstate = wxPyBeginAllowThreads();
27362 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27363
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 Py_INCREF(Py_None); resultobj = Py_None;
27368 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27369 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27370 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27371 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27372 return resultobj;
27373 fail:
27374 return NULL;
27375 }
27376
27377
27378 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27379 PyObject *resultobj;
27380 wxWindow *arg1 = (wxWindow *) 0 ;
27381 wxSize result;
27382 PyObject * obj0 = 0 ;
27383 char *kwnames[] = {
27384 (char *) "self", NULL
27385 };
27386
27387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27389 if (SWIG_arg_fail(1)) SWIG_fail;
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27393
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 {
27398 wxSize * resultptr;
27399 resultptr = new wxSize((wxSize &)(result));
27400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27401 }
27402 return resultobj;
27403 fail:
27404 return NULL;
27405 }
27406
27407
27408 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27409 PyObject *resultobj;
27410 wxWindow *arg1 = (wxWindow *) 0 ;
27411 bool arg2 = (bool) true ;
27412 bool result;
27413 PyObject * obj0 = 0 ;
27414 PyObject * obj1 = 0 ;
27415 char *kwnames[] = {
27416 (char *) "self",(char *) "show", NULL
27417 };
27418
27419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27421 if (SWIG_arg_fail(1)) SWIG_fail;
27422 if (obj1) {
27423 {
27424 arg2 = (bool)(SWIG_As_bool(obj1));
27425 if (SWIG_arg_fail(2)) SWIG_fail;
27426 }
27427 }
27428 {
27429 PyThreadState* __tstate = wxPyBeginAllowThreads();
27430 result = (bool)(arg1)->Show(arg2);
27431
27432 wxPyEndAllowThreads(__tstate);
27433 if (PyErr_Occurred()) SWIG_fail;
27434 }
27435 {
27436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27437 }
27438 return resultobj;
27439 fail:
27440 return NULL;
27441 }
27442
27443
27444 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27445 PyObject *resultobj;
27446 wxWindow *arg1 = (wxWindow *) 0 ;
27447 bool result;
27448 PyObject * obj0 = 0 ;
27449 char *kwnames[] = {
27450 (char *) "self", NULL
27451 };
27452
27453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27455 if (SWIG_arg_fail(1)) SWIG_fail;
27456 {
27457 PyThreadState* __tstate = wxPyBeginAllowThreads();
27458 result = (bool)(arg1)->Hide();
27459
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 {
27464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27465 }
27466 return resultobj;
27467 fail:
27468 return NULL;
27469 }
27470
27471
27472 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27473 PyObject *resultobj;
27474 wxWindow *arg1 = (wxWindow *) 0 ;
27475 bool arg2 = (bool) true ;
27476 bool result;
27477 PyObject * obj0 = 0 ;
27478 PyObject * obj1 = 0 ;
27479 char *kwnames[] = {
27480 (char *) "self",(char *) "enable", NULL
27481 };
27482
27483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27485 if (SWIG_arg_fail(1)) SWIG_fail;
27486 if (obj1) {
27487 {
27488 arg2 = (bool)(SWIG_As_bool(obj1));
27489 if (SWIG_arg_fail(2)) SWIG_fail;
27490 }
27491 }
27492 {
27493 PyThreadState* __tstate = wxPyBeginAllowThreads();
27494 result = (bool)(arg1)->Enable(arg2);
27495
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 {
27500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27501 }
27502 return resultobj;
27503 fail:
27504 return NULL;
27505 }
27506
27507
27508 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27509 PyObject *resultobj;
27510 wxWindow *arg1 = (wxWindow *) 0 ;
27511 bool result;
27512 PyObject * obj0 = 0 ;
27513 char *kwnames[] = {
27514 (char *) "self", NULL
27515 };
27516
27517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27519 if (SWIG_arg_fail(1)) SWIG_fail;
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 result = (bool)(arg1)->Disable();
27523
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 {
27528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27529 }
27530 return resultobj;
27531 fail:
27532 return NULL;
27533 }
27534
27535
27536 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27537 PyObject *resultobj;
27538 wxWindow *arg1 = (wxWindow *) 0 ;
27539 bool result;
27540 PyObject * obj0 = 0 ;
27541 char *kwnames[] = {
27542 (char *) "self", NULL
27543 };
27544
27545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27547 if (SWIG_arg_fail(1)) SWIG_fail;
27548 {
27549 PyThreadState* __tstate = wxPyBeginAllowThreads();
27550 result = (bool)((wxWindow const *)arg1)->IsShown();
27551
27552 wxPyEndAllowThreads(__tstate);
27553 if (PyErr_Occurred()) SWIG_fail;
27554 }
27555 {
27556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27557 }
27558 return resultobj;
27559 fail:
27560 return NULL;
27561 }
27562
27563
27564 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27565 PyObject *resultobj;
27566 wxWindow *arg1 = (wxWindow *) 0 ;
27567 bool result;
27568 PyObject * obj0 = 0 ;
27569 char *kwnames[] = {
27570 (char *) "self", NULL
27571 };
27572
27573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27575 if (SWIG_arg_fail(1)) SWIG_fail;
27576 {
27577 PyThreadState* __tstate = wxPyBeginAllowThreads();
27578 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27579
27580 wxPyEndAllowThreads(__tstate);
27581 if (PyErr_Occurred()) SWIG_fail;
27582 }
27583 {
27584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27585 }
27586 return resultobj;
27587 fail:
27588 return NULL;
27589 }
27590
27591
27592 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27593 PyObject *resultobj;
27594 wxWindow *arg1 = (wxWindow *) 0 ;
27595 long arg2 ;
27596 PyObject * obj0 = 0 ;
27597 PyObject * obj1 = 0 ;
27598 char *kwnames[] = {
27599 (char *) "self",(char *) "style", NULL
27600 };
27601
27602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27604 if (SWIG_arg_fail(1)) SWIG_fail;
27605 {
27606 arg2 = (long)(SWIG_As_long(obj1));
27607 if (SWIG_arg_fail(2)) SWIG_fail;
27608 }
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 (arg1)->SetWindowStyleFlag(arg2);
27612
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 Py_INCREF(Py_None); resultobj = Py_None;
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27624 PyObject *resultobj;
27625 wxWindow *arg1 = (wxWindow *) 0 ;
27626 long result;
27627 PyObject * obj0 = 0 ;
27628 char *kwnames[] = {
27629 (char *) "self", NULL
27630 };
27631
27632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27634 if (SWIG_arg_fail(1)) SWIG_fail;
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27638
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = SWIG_From_long((long)(result));
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxWindow *arg1 = (wxWindow *) 0 ;
27654 int arg2 ;
27655 bool result;
27656 PyObject * obj0 = 0 ;
27657 PyObject * obj1 = 0 ;
27658 char *kwnames[] = {
27659 (char *) "self",(char *) "flag", NULL
27660 };
27661
27662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27664 if (SWIG_arg_fail(1)) SWIG_fail;
27665 {
27666 arg2 = (int)(SWIG_As_int(obj1));
27667 if (SWIG_arg_fail(2)) SWIG_fail;
27668 }
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27672
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 {
27677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27678 }
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27686 PyObject *resultobj;
27687 wxWindow *arg1 = (wxWindow *) 0 ;
27688 bool result;
27689 PyObject * obj0 = 0 ;
27690 char *kwnames[] = {
27691 (char *) "self", NULL
27692 };
27693
27694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27696 if (SWIG_arg_fail(1)) SWIG_fail;
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 result = (bool)((wxWindow const *)arg1)->IsRetained();
27700
27701 wxPyEndAllowThreads(__tstate);
27702 if (PyErr_Occurred()) SWIG_fail;
27703 }
27704 {
27705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27706 }
27707 return resultobj;
27708 fail:
27709 return NULL;
27710 }
27711
27712
27713 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27714 PyObject *resultobj;
27715 wxWindow *arg1 = (wxWindow *) 0 ;
27716 long arg2 ;
27717 PyObject * obj0 = 0 ;
27718 PyObject * obj1 = 0 ;
27719 char *kwnames[] = {
27720 (char *) "self",(char *) "exStyle", NULL
27721 };
27722
27723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27725 if (SWIG_arg_fail(1)) SWIG_fail;
27726 {
27727 arg2 = (long)(SWIG_As_long(obj1));
27728 if (SWIG_arg_fail(2)) SWIG_fail;
27729 }
27730 {
27731 PyThreadState* __tstate = wxPyBeginAllowThreads();
27732 (arg1)->SetExtraStyle(arg2);
27733
27734 wxPyEndAllowThreads(__tstate);
27735 if (PyErr_Occurred()) SWIG_fail;
27736 }
27737 Py_INCREF(Py_None); resultobj = Py_None;
27738 return resultobj;
27739 fail:
27740 return NULL;
27741 }
27742
27743
27744 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27745 PyObject *resultobj;
27746 wxWindow *arg1 = (wxWindow *) 0 ;
27747 long result;
27748 PyObject * obj0 = 0 ;
27749 char *kwnames[] = {
27750 (char *) "self", NULL
27751 };
27752
27753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27755 if (SWIG_arg_fail(1)) SWIG_fail;
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27759
27760 wxPyEndAllowThreads(__tstate);
27761 if (PyErr_Occurred()) SWIG_fail;
27762 }
27763 {
27764 resultobj = SWIG_From_long((long)(result));
27765 }
27766 return resultobj;
27767 fail:
27768 return NULL;
27769 }
27770
27771
27772 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27773 PyObject *resultobj;
27774 wxWindow *arg1 = (wxWindow *) 0 ;
27775 bool arg2 = (bool) true ;
27776 PyObject * obj0 = 0 ;
27777 PyObject * obj1 = 0 ;
27778 char *kwnames[] = {
27779 (char *) "self",(char *) "modal", NULL
27780 };
27781
27782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27784 if (SWIG_arg_fail(1)) SWIG_fail;
27785 if (obj1) {
27786 {
27787 arg2 = (bool)(SWIG_As_bool(obj1));
27788 if (SWIG_arg_fail(2)) SWIG_fail;
27789 }
27790 }
27791 {
27792 PyThreadState* __tstate = wxPyBeginAllowThreads();
27793 (arg1)->MakeModal(arg2);
27794
27795 wxPyEndAllowThreads(__tstate);
27796 if (PyErr_Occurred()) SWIG_fail;
27797 }
27798 Py_INCREF(Py_None); resultobj = Py_None;
27799 return resultobj;
27800 fail:
27801 return NULL;
27802 }
27803
27804
27805 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27806 PyObject *resultobj;
27807 wxWindow *arg1 = (wxWindow *) 0 ;
27808 bool arg2 ;
27809 PyObject * obj0 = 0 ;
27810 PyObject * obj1 = 0 ;
27811 char *kwnames[] = {
27812 (char *) "self",(char *) "enableTheme", NULL
27813 };
27814
27815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27817 if (SWIG_arg_fail(1)) SWIG_fail;
27818 {
27819 arg2 = (bool)(SWIG_As_bool(obj1));
27820 if (SWIG_arg_fail(2)) SWIG_fail;
27821 }
27822 {
27823 PyThreadState* __tstate = wxPyBeginAllowThreads();
27824 (arg1)->SetThemeEnabled(arg2);
27825
27826 wxPyEndAllowThreads(__tstate);
27827 if (PyErr_Occurred()) SWIG_fail;
27828 }
27829 Py_INCREF(Py_None); resultobj = Py_None;
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27837 PyObject *resultobj;
27838 wxWindow *arg1 = (wxWindow *) 0 ;
27839 bool result;
27840 PyObject * obj0 = 0 ;
27841 char *kwnames[] = {
27842 (char *) "self", NULL
27843 };
27844
27845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27847 if (SWIG_arg_fail(1)) SWIG_fail;
27848 {
27849 PyThreadState* __tstate = wxPyBeginAllowThreads();
27850 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27851
27852 wxPyEndAllowThreads(__tstate);
27853 if (PyErr_Occurred()) SWIG_fail;
27854 }
27855 {
27856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27857 }
27858 return resultobj;
27859 fail:
27860 return NULL;
27861 }
27862
27863
27864 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27865 PyObject *resultobj;
27866 wxWindow *arg1 = (wxWindow *) 0 ;
27867 PyObject * obj0 = 0 ;
27868 char *kwnames[] = {
27869 (char *) "self", NULL
27870 };
27871
27872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27874 if (SWIG_arg_fail(1)) SWIG_fail;
27875 {
27876 PyThreadState* __tstate = wxPyBeginAllowThreads();
27877 (arg1)->SetFocus();
27878
27879 wxPyEndAllowThreads(__tstate);
27880 if (PyErr_Occurred()) SWIG_fail;
27881 }
27882 Py_INCREF(Py_None); resultobj = Py_None;
27883 return resultobj;
27884 fail:
27885 return NULL;
27886 }
27887
27888
27889 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27890 PyObject *resultobj;
27891 wxWindow *arg1 = (wxWindow *) 0 ;
27892 PyObject * obj0 = 0 ;
27893 char *kwnames[] = {
27894 (char *) "self", NULL
27895 };
27896
27897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27899 if (SWIG_arg_fail(1)) SWIG_fail;
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 (arg1)->SetFocusFromKbd();
27903
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 Py_INCREF(Py_None); resultobj = Py_None;
27908 return resultobj;
27909 fail:
27910 return NULL;
27911 }
27912
27913
27914 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27915 PyObject *resultobj;
27916 wxWindow *result;
27917 char *kwnames[] = {
27918 NULL
27919 };
27920
27921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27922 {
27923 if (!wxPyCheckForApp()) SWIG_fail;
27924 PyThreadState* __tstate = wxPyBeginAllowThreads();
27925 result = (wxWindow *)wxWindow::FindFocus();
27926
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 {
27931 resultobj = wxPyMake_wxObject(result, 0);
27932 }
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27940 PyObject *resultobj;
27941 wxWindow *arg1 = (wxWindow *) 0 ;
27942 bool result;
27943 PyObject * obj0 = 0 ;
27944 char *kwnames[] = {
27945 (char *) "self", NULL
27946 };
27947
27948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27950 if (SWIG_arg_fail(1)) SWIG_fail;
27951 {
27952 PyThreadState* __tstate = wxPyBeginAllowThreads();
27953 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27954
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 {
27959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27960 }
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj;
27969 wxWindow *arg1 = (wxWindow *) 0 ;
27970 bool result;
27971 PyObject * obj0 = 0 ;
27972 char *kwnames[] = {
27973 (char *) "self", NULL
27974 };
27975
27976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27978 if (SWIG_arg_fail(1)) SWIG_fail;
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27982
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 {
27987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27988 }
27989 return resultobj;
27990 fail:
27991 return NULL;
27992 }
27993
27994
27995 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27996 PyObject *resultobj;
27997 wxWindow *arg1 = (wxWindow *) 0 ;
27998 wxWindow *result;
27999 PyObject * obj0 = 0 ;
28000 char *kwnames[] = {
28001 (char *) "self", NULL
28002 };
28003
28004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28006 if (SWIG_arg_fail(1)) SWIG_fail;
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28010
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 {
28015 resultobj = wxPyMake_wxObject(result, 0);
28016 }
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28024 PyObject *resultobj;
28025 wxWindow *arg1 = (wxWindow *) 0 ;
28026 wxWindow *arg2 = (wxWindow *) 0 ;
28027 wxWindow *result;
28028 PyObject * obj0 = 0 ;
28029 PyObject * obj1 = 0 ;
28030 char *kwnames[] = {
28031 (char *) "self",(char *) "child", NULL
28032 };
28033
28034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28036 if (SWIG_arg_fail(1)) SWIG_fail;
28037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28038 if (SWIG_arg_fail(2)) SWIG_fail;
28039 {
28040 PyThreadState* __tstate = wxPyBeginAllowThreads();
28041 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28042
28043 wxPyEndAllowThreads(__tstate);
28044 if (PyErr_Occurred()) SWIG_fail;
28045 }
28046 {
28047 resultobj = wxPyMake_wxObject(result, 0);
28048 }
28049 return resultobj;
28050 fail:
28051 return NULL;
28052 }
28053
28054
28055 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28056 PyObject *resultobj;
28057 wxWindow *arg1 = (wxWindow *) 0 ;
28058 wxWindow *arg2 = (wxWindow *) 0 ;
28059 PyObject * obj0 = 0 ;
28060 PyObject * obj1 = 0 ;
28061 char *kwnames[] = {
28062 (char *) "self",(char *) "win", NULL
28063 };
28064
28065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28067 if (SWIG_arg_fail(1)) SWIG_fail;
28068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28069 if (SWIG_arg_fail(2)) SWIG_fail;
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 (arg1)->SetTmpDefaultItem(arg2);
28073
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 Py_INCREF(Py_None); resultobj = Py_None;
28078 return resultobj;
28079 fail:
28080 return NULL;
28081 }
28082
28083
28084 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28085 PyObject *resultobj;
28086 wxWindow *arg1 = (wxWindow *) 0 ;
28087 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28088 bool result;
28089 PyObject * obj0 = 0 ;
28090 PyObject * obj1 = 0 ;
28091 char *kwnames[] = {
28092 (char *) "self",(char *) "flags", NULL
28093 };
28094
28095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28097 if (SWIG_arg_fail(1)) SWIG_fail;
28098 if (obj1) {
28099 {
28100 arg2 = (int)(SWIG_As_int(obj1));
28101 if (SWIG_arg_fail(2)) SWIG_fail;
28102 }
28103 }
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 result = (bool)(arg1)->Navigate(arg2);
28107
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 {
28112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28113 }
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28121 PyObject *resultobj;
28122 wxWindow *arg1 = (wxWindow *) 0 ;
28123 wxWindow *arg2 = (wxWindow *) 0 ;
28124 PyObject * obj0 = 0 ;
28125 PyObject * obj1 = 0 ;
28126 char *kwnames[] = {
28127 (char *) "self",(char *) "win", NULL
28128 };
28129
28130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28132 if (SWIG_arg_fail(1)) SWIG_fail;
28133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28134 if (SWIG_arg_fail(2)) SWIG_fail;
28135 {
28136 PyThreadState* __tstate = wxPyBeginAllowThreads();
28137 (arg1)->MoveAfterInTabOrder(arg2);
28138
28139 wxPyEndAllowThreads(__tstate);
28140 if (PyErr_Occurred()) SWIG_fail;
28141 }
28142 Py_INCREF(Py_None); resultobj = Py_None;
28143 return resultobj;
28144 fail:
28145 return NULL;
28146 }
28147
28148
28149 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28150 PyObject *resultobj;
28151 wxWindow *arg1 = (wxWindow *) 0 ;
28152 wxWindow *arg2 = (wxWindow *) 0 ;
28153 PyObject * obj0 = 0 ;
28154 PyObject * obj1 = 0 ;
28155 char *kwnames[] = {
28156 (char *) "self",(char *) "win", NULL
28157 };
28158
28159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28161 if (SWIG_arg_fail(1)) SWIG_fail;
28162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28163 if (SWIG_arg_fail(2)) SWIG_fail;
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 (arg1)->MoveBeforeInTabOrder(arg2);
28167
28168 wxPyEndAllowThreads(__tstate);
28169 if (PyErr_Occurred()) SWIG_fail;
28170 }
28171 Py_INCREF(Py_None); resultobj = Py_None;
28172 return resultobj;
28173 fail:
28174 return NULL;
28175 }
28176
28177
28178 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28179 PyObject *resultobj;
28180 wxWindow *arg1 = (wxWindow *) 0 ;
28181 PyObject *result;
28182 PyObject * obj0 = 0 ;
28183 char *kwnames[] = {
28184 (char *) "self", NULL
28185 };
28186
28187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28189 if (SWIG_arg_fail(1)) SWIG_fail;
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = (PyObject *)wxWindow_GetChildren(arg1);
28193
28194 wxPyEndAllowThreads(__tstate);
28195 if (PyErr_Occurred()) SWIG_fail;
28196 }
28197 resultobj = result;
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28205 PyObject *resultobj;
28206 wxWindow *arg1 = (wxWindow *) 0 ;
28207 wxWindow *result;
28208 PyObject * obj0 = 0 ;
28209 char *kwnames[] = {
28210 (char *) "self", NULL
28211 };
28212
28213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28215 if (SWIG_arg_fail(1)) SWIG_fail;
28216 {
28217 PyThreadState* __tstate = wxPyBeginAllowThreads();
28218 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28219
28220 wxPyEndAllowThreads(__tstate);
28221 if (PyErr_Occurred()) SWIG_fail;
28222 }
28223 {
28224 resultobj = wxPyMake_wxObject(result, 0);
28225 }
28226 return resultobj;
28227 fail:
28228 return NULL;
28229 }
28230
28231
28232 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28233 PyObject *resultobj;
28234 wxWindow *arg1 = (wxWindow *) 0 ;
28235 wxWindow *result;
28236 PyObject * obj0 = 0 ;
28237 char *kwnames[] = {
28238 (char *) "self", NULL
28239 };
28240
28241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28243 if (SWIG_arg_fail(1)) SWIG_fail;
28244 {
28245 PyThreadState* __tstate = wxPyBeginAllowThreads();
28246 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28247
28248 wxPyEndAllowThreads(__tstate);
28249 if (PyErr_Occurred()) SWIG_fail;
28250 }
28251 {
28252 resultobj = wxPyMake_wxObject(result, 0);
28253 }
28254 return resultobj;
28255 fail:
28256 return NULL;
28257 }
28258
28259
28260 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28261 PyObject *resultobj;
28262 wxWindow *arg1 = (wxWindow *) 0 ;
28263 bool result;
28264 PyObject * obj0 = 0 ;
28265 char *kwnames[] = {
28266 (char *) "self", NULL
28267 };
28268
28269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28271 if (SWIG_arg_fail(1)) SWIG_fail;
28272 {
28273 PyThreadState* __tstate = wxPyBeginAllowThreads();
28274 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28275
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 {
28280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28281 }
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28289 PyObject *resultobj;
28290 wxWindow *arg1 = (wxWindow *) 0 ;
28291 wxWindow *arg2 = (wxWindow *) 0 ;
28292 bool result;
28293 PyObject * obj0 = 0 ;
28294 PyObject * obj1 = 0 ;
28295 char *kwnames[] = {
28296 (char *) "self",(char *) "newParent", NULL
28297 };
28298
28299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28301 if (SWIG_arg_fail(1)) SWIG_fail;
28302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28303 if (SWIG_arg_fail(2)) SWIG_fail;
28304 {
28305 PyThreadState* __tstate = wxPyBeginAllowThreads();
28306 result = (bool)(arg1)->Reparent(arg2);
28307
28308 wxPyEndAllowThreads(__tstate);
28309 if (PyErr_Occurred()) SWIG_fail;
28310 }
28311 {
28312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28313 }
28314 return resultobj;
28315 fail:
28316 return NULL;
28317 }
28318
28319
28320 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28321 PyObject *resultobj;
28322 wxWindow *arg1 = (wxWindow *) 0 ;
28323 wxWindow *arg2 = (wxWindow *) 0 ;
28324 PyObject * obj0 = 0 ;
28325 PyObject * obj1 = 0 ;
28326 char *kwnames[] = {
28327 (char *) "self",(char *) "child", NULL
28328 };
28329
28330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28334 if (SWIG_arg_fail(2)) SWIG_fail;
28335 {
28336 PyThreadState* __tstate = wxPyBeginAllowThreads();
28337 (arg1)->AddChild(arg2);
28338
28339 wxPyEndAllowThreads(__tstate);
28340 if (PyErr_Occurred()) SWIG_fail;
28341 }
28342 Py_INCREF(Py_None); resultobj = Py_None;
28343 return resultobj;
28344 fail:
28345 return NULL;
28346 }
28347
28348
28349 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28350 PyObject *resultobj;
28351 wxWindow *arg1 = (wxWindow *) 0 ;
28352 wxWindow *arg2 = (wxWindow *) 0 ;
28353 PyObject * obj0 = 0 ;
28354 PyObject * obj1 = 0 ;
28355 char *kwnames[] = {
28356 (char *) "self",(char *) "child", NULL
28357 };
28358
28359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28361 if (SWIG_arg_fail(1)) SWIG_fail;
28362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28363 if (SWIG_arg_fail(2)) SWIG_fail;
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 (arg1)->RemoveChild(arg2);
28367
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 Py_INCREF(Py_None); resultobj = Py_None;
28372 return resultobj;
28373 fail:
28374 return NULL;
28375 }
28376
28377
28378 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj;
28380 wxWindow *arg1 = (wxWindow *) 0 ;
28381 long arg2 ;
28382 wxWindow *result;
28383 PyObject * obj0 = 0 ;
28384 PyObject * obj1 = 0 ;
28385 char *kwnames[] = {
28386 (char *) "self",(char *) "winid", NULL
28387 };
28388
28389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28391 if (SWIG_arg_fail(1)) SWIG_fail;
28392 {
28393 arg2 = (long)(SWIG_As_long(obj1));
28394 if (SWIG_arg_fail(2)) SWIG_fail;
28395 }
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (wxWindow *)(arg1)->FindWindow(arg2);
28399
28400 wxPyEndAllowThreads(__tstate);
28401 if (PyErr_Occurred()) SWIG_fail;
28402 }
28403 {
28404 resultobj = wxPyMake_wxObject(result, 0);
28405 }
28406 return resultobj;
28407 fail:
28408 return NULL;
28409 }
28410
28411
28412 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28413 PyObject *resultobj;
28414 wxWindow *arg1 = (wxWindow *) 0 ;
28415 wxString *arg2 = 0 ;
28416 wxWindow *result;
28417 bool temp2 = false ;
28418 PyObject * obj0 = 0 ;
28419 PyObject * obj1 = 0 ;
28420 char *kwnames[] = {
28421 (char *) "self",(char *) "name", NULL
28422 };
28423
28424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28426 if (SWIG_arg_fail(1)) SWIG_fail;
28427 {
28428 arg2 = wxString_in_helper(obj1);
28429 if (arg2 == NULL) SWIG_fail;
28430 temp2 = true;
28431 }
28432 {
28433 PyThreadState* __tstate = wxPyBeginAllowThreads();
28434 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28435
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 {
28440 resultobj = wxPyMake_wxObject(result, 0);
28441 }
28442 {
28443 if (temp2)
28444 delete arg2;
28445 }
28446 return resultobj;
28447 fail:
28448 {
28449 if (temp2)
28450 delete arg2;
28451 }
28452 return NULL;
28453 }
28454
28455
28456 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28457 PyObject *resultobj;
28458 wxWindow *arg1 = (wxWindow *) 0 ;
28459 wxEvtHandler *result;
28460 PyObject * obj0 = 0 ;
28461 char *kwnames[] = {
28462 (char *) "self", NULL
28463 };
28464
28465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28467 if (SWIG_arg_fail(1)) SWIG_fail;
28468 {
28469 PyThreadState* __tstate = wxPyBeginAllowThreads();
28470 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28471
28472 wxPyEndAllowThreads(__tstate);
28473 if (PyErr_Occurred()) SWIG_fail;
28474 }
28475 {
28476 resultobj = wxPyMake_wxObject(result, 0);
28477 }
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28485 PyObject *resultobj;
28486 wxWindow *arg1 = (wxWindow *) 0 ;
28487 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28488 PyObject * obj0 = 0 ;
28489 PyObject * obj1 = 0 ;
28490 char *kwnames[] = {
28491 (char *) "self",(char *) "handler", NULL
28492 };
28493
28494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28496 if (SWIG_arg_fail(1)) SWIG_fail;
28497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28498 if (SWIG_arg_fail(2)) SWIG_fail;
28499 {
28500 PyThreadState* __tstate = wxPyBeginAllowThreads();
28501 (arg1)->SetEventHandler(arg2);
28502
28503 wxPyEndAllowThreads(__tstate);
28504 if (PyErr_Occurred()) SWIG_fail;
28505 }
28506 Py_INCREF(Py_None); resultobj = Py_None;
28507 return resultobj;
28508 fail:
28509 return NULL;
28510 }
28511
28512
28513 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28514 PyObject *resultobj;
28515 wxWindow *arg1 = (wxWindow *) 0 ;
28516 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28517 PyObject * obj0 = 0 ;
28518 PyObject * obj1 = 0 ;
28519 char *kwnames[] = {
28520 (char *) "self",(char *) "handler", NULL
28521 };
28522
28523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28525 if (SWIG_arg_fail(1)) SWIG_fail;
28526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28527 if (SWIG_arg_fail(2)) SWIG_fail;
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 (arg1)->PushEventHandler(arg2);
28531
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 Py_INCREF(Py_None); resultobj = Py_None;
28536 return resultobj;
28537 fail:
28538 return NULL;
28539 }
28540
28541
28542 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28543 PyObject *resultobj;
28544 wxWindow *arg1 = (wxWindow *) 0 ;
28545 bool arg2 = (bool) false ;
28546 wxEvtHandler *result;
28547 PyObject * obj0 = 0 ;
28548 PyObject * obj1 = 0 ;
28549 char *kwnames[] = {
28550 (char *) "self",(char *) "deleteHandler", NULL
28551 };
28552
28553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(1)) SWIG_fail;
28556 if (obj1) {
28557 {
28558 arg2 = (bool)(SWIG_As_bool(obj1));
28559 if (SWIG_arg_fail(2)) SWIG_fail;
28560 }
28561 }
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28565
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 {
28570 resultobj = wxPyMake_wxObject(result, 0);
28571 }
28572 return resultobj;
28573 fail:
28574 return NULL;
28575 }
28576
28577
28578 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28579 PyObject *resultobj;
28580 wxWindow *arg1 = (wxWindow *) 0 ;
28581 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28582 bool result;
28583 PyObject * obj0 = 0 ;
28584 PyObject * obj1 = 0 ;
28585 char *kwnames[] = {
28586 (char *) "self",(char *) "handler", NULL
28587 };
28588
28589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(1)) SWIG_fail;
28592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28593 if (SWIG_arg_fail(2)) SWIG_fail;
28594 {
28595 PyThreadState* __tstate = wxPyBeginAllowThreads();
28596 result = (bool)(arg1)->RemoveEventHandler(arg2);
28597
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 {
28602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28603 }
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28611 PyObject *resultobj;
28612 wxWindow *arg1 = (wxWindow *) 0 ;
28613 wxValidator *arg2 = 0 ;
28614 PyObject * obj0 = 0 ;
28615 PyObject * obj1 = 0 ;
28616 char *kwnames[] = {
28617 (char *) "self",(char *) "validator", NULL
28618 };
28619
28620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28625 if (SWIG_arg_fail(2)) SWIG_fail;
28626 if (arg2 == NULL) {
28627 SWIG_null_ref("wxValidator");
28628 }
28629 if (SWIG_arg_fail(2)) SWIG_fail;
28630 }
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 (arg1)->SetValidator((wxValidator const &)*arg2);
28634
28635 wxPyEndAllowThreads(__tstate);
28636 if (PyErr_Occurred()) SWIG_fail;
28637 }
28638 Py_INCREF(Py_None); resultobj = Py_None;
28639 return resultobj;
28640 fail:
28641 return NULL;
28642 }
28643
28644
28645 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28646 PyObject *resultobj;
28647 wxWindow *arg1 = (wxWindow *) 0 ;
28648 wxValidator *result;
28649 PyObject * obj0 = 0 ;
28650 char *kwnames[] = {
28651 (char *) "self", NULL
28652 };
28653
28654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(1)) SWIG_fail;
28657 {
28658 PyThreadState* __tstate = wxPyBeginAllowThreads();
28659 result = (wxValidator *)(arg1)->GetValidator();
28660
28661 wxPyEndAllowThreads(__tstate);
28662 if (PyErr_Occurred()) SWIG_fail;
28663 }
28664 {
28665 resultobj = wxPyMake_wxObject(result, 0);
28666 }
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28674 PyObject *resultobj;
28675 wxWindow *arg1 = (wxWindow *) 0 ;
28676 bool result;
28677 PyObject * obj0 = 0 ;
28678 char *kwnames[] = {
28679 (char *) "self", NULL
28680 };
28681
28682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28684 if (SWIG_arg_fail(1)) SWIG_fail;
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = (bool)(arg1)->Validate();
28688
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 {
28693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28694 }
28695 return resultobj;
28696 fail:
28697 return NULL;
28698 }
28699
28700
28701 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28702 PyObject *resultobj;
28703 wxWindow *arg1 = (wxWindow *) 0 ;
28704 bool result;
28705 PyObject * obj0 = 0 ;
28706 char *kwnames[] = {
28707 (char *) "self", NULL
28708 };
28709
28710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28712 if (SWIG_arg_fail(1)) SWIG_fail;
28713 {
28714 PyThreadState* __tstate = wxPyBeginAllowThreads();
28715 result = (bool)(arg1)->TransferDataToWindow();
28716
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 {
28721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28722 }
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28730 PyObject *resultobj;
28731 wxWindow *arg1 = (wxWindow *) 0 ;
28732 bool result;
28733 PyObject * obj0 = 0 ;
28734 char *kwnames[] = {
28735 (char *) "self", NULL
28736 };
28737
28738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28740 if (SWIG_arg_fail(1)) SWIG_fail;
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 result = (bool)(arg1)->TransferDataFromWindow();
28744
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 {
28749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28750 }
28751 return resultobj;
28752 fail:
28753 return NULL;
28754 }
28755
28756
28757 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28758 PyObject *resultobj;
28759 wxWindow *arg1 = (wxWindow *) 0 ;
28760 PyObject * obj0 = 0 ;
28761 char *kwnames[] = {
28762 (char *) "self", NULL
28763 };
28764
28765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28767 if (SWIG_arg_fail(1)) SWIG_fail;
28768 {
28769 PyThreadState* __tstate = wxPyBeginAllowThreads();
28770 (arg1)->InitDialog();
28771
28772 wxPyEndAllowThreads(__tstate);
28773 if (PyErr_Occurred()) SWIG_fail;
28774 }
28775 Py_INCREF(Py_None); resultobj = Py_None;
28776 return resultobj;
28777 fail:
28778 return NULL;
28779 }
28780
28781
28782 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28783 PyObject *resultobj;
28784 wxWindow *arg1 = (wxWindow *) 0 ;
28785 wxAcceleratorTable *arg2 = 0 ;
28786 PyObject * obj0 = 0 ;
28787 PyObject * obj1 = 0 ;
28788 char *kwnames[] = {
28789 (char *) "self",(char *) "accel", NULL
28790 };
28791
28792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28794 if (SWIG_arg_fail(1)) SWIG_fail;
28795 {
28796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28797 if (SWIG_arg_fail(2)) SWIG_fail;
28798 if (arg2 == NULL) {
28799 SWIG_null_ref("wxAcceleratorTable");
28800 }
28801 if (SWIG_arg_fail(2)) SWIG_fail;
28802 }
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28806
28807 wxPyEndAllowThreads(__tstate);
28808 if (PyErr_Occurred()) SWIG_fail;
28809 }
28810 Py_INCREF(Py_None); resultobj = Py_None;
28811 return resultobj;
28812 fail:
28813 return NULL;
28814 }
28815
28816
28817 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28818 PyObject *resultobj;
28819 wxWindow *arg1 = (wxWindow *) 0 ;
28820 wxAcceleratorTable *result;
28821 PyObject * obj0 = 0 ;
28822 char *kwnames[] = {
28823 (char *) "self", NULL
28824 };
28825
28826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28828 if (SWIG_arg_fail(1)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28832
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj;
28845 wxWindow *arg1 = (wxWindow *) 0 ;
28846 int arg2 ;
28847 int arg3 ;
28848 int arg4 ;
28849 bool result;
28850 PyObject * obj0 = 0 ;
28851 PyObject * obj1 = 0 ;
28852 PyObject * obj2 = 0 ;
28853 PyObject * obj3 = 0 ;
28854 char *kwnames[] = {
28855 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28856 };
28857
28858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28860 if (SWIG_arg_fail(1)) SWIG_fail;
28861 {
28862 arg2 = (int)(SWIG_As_int(obj1));
28863 if (SWIG_arg_fail(2)) SWIG_fail;
28864 }
28865 {
28866 arg3 = (int)(SWIG_As_int(obj2));
28867 if (SWIG_arg_fail(3)) SWIG_fail;
28868 }
28869 {
28870 arg4 = (int)(SWIG_As_int(obj3));
28871 if (SWIG_arg_fail(4)) SWIG_fail;
28872 }
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 {
28881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28882 }
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj;
28891 wxWindow *arg1 = (wxWindow *) 0 ;
28892 int arg2 ;
28893 bool result;
28894 PyObject * obj0 = 0 ;
28895 PyObject * obj1 = 0 ;
28896 char *kwnames[] = {
28897 (char *) "self",(char *) "hotkeyId", NULL
28898 };
28899
28900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28902 if (SWIG_arg_fail(1)) SWIG_fail;
28903 {
28904 arg2 = (int)(SWIG_As_int(obj1));
28905 if (SWIG_arg_fail(2)) SWIG_fail;
28906 }
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28910
28911 wxPyEndAllowThreads(__tstate);
28912 if (PyErr_Occurred()) SWIG_fail;
28913 }
28914 {
28915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28916 }
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj;
28925 wxWindow *arg1 = (wxWindow *) 0 ;
28926 wxPoint *arg2 = 0 ;
28927 wxPoint result;
28928 wxPoint temp2 ;
28929 PyObject * obj0 = 0 ;
28930 PyObject * obj1 = 0 ;
28931 char *kwnames[] = {
28932 (char *) "self",(char *) "pt", NULL
28933 };
28934
28935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28937 if (SWIG_arg_fail(1)) SWIG_fail;
28938 {
28939 arg2 = &temp2;
28940 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28941 }
28942 {
28943 PyThreadState* __tstate = wxPyBeginAllowThreads();
28944 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28945
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 {
28950 wxPoint * resultptr;
28951 resultptr = new wxPoint((wxPoint &)(result));
28952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28953 }
28954 return resultobj;
28955 fail:
28956 return NULL;
28957 }
28958
28959
28960 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28961 PyObject *resultobj;
28962 wxWindow *arg1 = (wxWindow *) 0 ;
28963 wxSize *arg2 = 0 ;
28964 wxSize result;
28965 wxSize temp2 ;
28966 PyObject * obj0 = 0 ;
28967 PyObject * obj1 = 0 ;
28968 char *kwnames[] = {
28969 (char *) "self",(char *) "sz", NULL
28970 };
28971
28972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28974 if (SWIG_arg_fail(1)) SWIG_fail;
28975 {
28976 arg2 = &temp2;
28977 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28978 }
28979 {
28980 PyThreadState* __tstate = wxPyBeginAllowThreads();
28981 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28982
28983 wxPyEndAllowThreads(__tstate);
28984 if (PyErr_Occurred()) SWIG_fail;
28985 }
28986 {
28987 wxSize * resultptr;
28988 resultptr = new wxSize((wxSize &)(result));
28989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28990 }
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28998 PyObject *resultobj;
28999 wxWindow *arg1 = (wxWindow *) 0 ;
29000 wxPoint *arg2 = 0 ;
29001 wxPoint result;
29002 wxPoint temp2 ;
29003 PyObject * obj0 = 0 ;
29004 PyObject * obj1 = 0 ;
29005 char *kwnames[] = {
29006 (char *) "self",(char *) "pt", NULL
29007 };
29008
29009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29011 if (SWIG_arg_fail(1)) SWIG_fail;
29012 {
29013 arg2 = &temp2;
29014 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29015 }
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29019
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 {
29024 wxPoint * resultptr;
29025 resultptr = new wxPoint((wxPoint &)(result));
29026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29027 }
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj;
29036 wxWindow *arg1 = (wxWindow *) 0 ;
29037 wxSize *arg2 = 0 ;
29038 wxSize result;
29039 wxSize temp2 ;
29040 PyObject * obj0 = 0 ;
29041 PyObject * obj1 = 0 ;
29042 char *kwnames[] = {
29043 (char *) "self",(char *) "sz", NULL
29044 };
29045
29046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29048 if (SWIG_arg_fail(1)) SWIG_fail;
29049 {
29050 arg2 = &temp2;
29051 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29052 }
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29056
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 {
29061 wxSize * resultptr;
29062 resultptr = new wxSize((wxSize &)(result));
29063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29064 }
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29072 PyObject *resultobj;
29073 wxWindow *arg1 = (wxWindow *) 0 ;
29074 wxPoint *arg2 = 0 ;
29075 wxPoint result;
29076 wxPoint temp2 ;
29077 PyObject * obj0 = 0 ;
29078 PyObject * obj1 = 0 ;
29079 char *kwnames[] = {
29080 (char *) "self",(char *) "pt", NULL
29081 };
29082
29083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29085 if (SWIG_arg_fail(1)) SWIG_fail;
29086 {
29087 arg2 = &temp2;
29088 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29089 }
29090 {
29091 PyThreadState* __tstate = wxPyBeginAllowThreads();
29092 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29093
29094 wxPyEndAllowThreads(__tstate);
29095 if (PyErr_Occurred()) SWIG_fail;
29096 }
29097 {
29098 wxPoint * resultptr;
29099 resultptr = new wxPoint((wxPoint &)(result));
29100 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29101 }
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj;
29110 wxWindow *arg1 = (wxWindow *) 0 ;
29111 wxSize *arg2 = 0 ;
29112 wxSize result;
29113 wxSize temp2 ;
29114 PyObject * obj0 = 0 ;
29115 PyObject * obj1 = 0 ;
29116 char *kwnames[] = {
29117 (char *) "self",(char *) "sz", NULL
29118 };
29119
29120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29122 if (SWIG_arg_fail(1)) SWIG_fail;
29123 {
29124 arg2 = &temp2;
29125 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29126 }
29127 {
29128 PyThreadState* __tstate = wxPyBeginAllowThreads();
29129 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29130
29131 wxPyEndAllowThreads(__tstate);
29132 if (PyErr_Occurred()) SWIG_fail;
29133 }
29134 {
29135 wxSize * resultptr;
29136 resultptr = new wxSize((wxSize &)(result));
29137 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29138 }
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29146 PyObject *resultobj;
29147 wxWindow *arg1 = (wxWindow *) 0 ;
29148 int arg2 ;
29149 int arg3 ;
29150 PyObject * obj0 = 0 ;
29151 PyObject * obj1 = 0 ;
29152 PyObject * obj2 = 0 ;
29153 char *kwnames[] = {
29154 (char *) "self",(char *) "x",(char *) "y", NULL
29155 };
29156
29157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29159 if (SWIG_arg_fail(1)) SWIG_fail;
29160 {
29161 arg2 = (int)(SWIG_As_int(obj1));
29162 if (SWIG_arg_fail(2)) SWIG_fail;
29163 }
29164 {
29165 arg3 = (int)(SWIG_As_int(obj2));
29166 if (SWIG_arg_fail(3)) SWIG_fail;
29167 }
29168 {
29169 PyThreadState* __tstate = wxPyBeginAllowThreads();
29170 (arg1)->WarpPointer(arg2,arg3);
29171
29172 wxPyEndAllowThreads(__tstate);
29173 if (PyErr_Occurred()) SWIG_fail;
29174 }
29175 Py_INCREF(Py_None); resultobj = Py_None;
29176 return resultobj;
29177 fail:
29178 return NULL;
29179 }
29180
29181
29182 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29183 PyObject *resultobj;
29184 wxWindow *arg1 = (wxWindow *) 0 ;
29185 PyObject * obj0 = 0 ;
29186 char *kwnames[] = {
29187 (char *) "self", NULL
29188 };
29189
29190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29192 if (SWIG_arg_fail(1)) SWIG_fail;
29193 {
29194 PyThreadState* __tstate = wxPyBeginAllowThreads();
29195 (arg1)->CaptureMouse();
29196
29197 wxPyEndAllowThreads(__tstate);
29198 if (PyErr_Occurred()) SWIG_fail;
29199 }
29200 Py_INCREF(Py_None); resultobj = Py_None;
29201 return resultobj;
29202 fail:
29203 return NULL;
29204 }
29205
29206
29207 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29208 PyObject *resultobj;
29209 wxWindow *arg1 = (wxWindow *) 0 ;
29210 PyObject * obj0 = 0 ;
29211 char *kwnames[] = {
29212 (char *) "self", NULL
29213 };
29214
29215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29217 if (SWIG_arg_fail(1)) SWIG_fail;
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 (arg1)->ReleaseMouse();
29221
29222 wxPyEndAllowThreads(__tstate);
29223 if (PyErr_Occurred()) SWIG_fail;
29224 }
29225 Py_INCREF(Py_None); resultobj = Py_None;
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29233 PyObject *resultobj;
29234 wxWindow *result;
29235 char *kwnames[] = {
29236 NULL
29237 };
29238
29239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29240 {
29241 if (!wxPyCheckForApp()) SWIG_fail;
29242 PyThreadState* __tstate = wxPyBeginAllowThreads();
29243 result = (wxWindow *)wxWindow::GetCapture();
29244
29245 wxPyEndAllowThreads(__tstate);
29246 if (PyErr_Occurred()) SWIG_fail;
29247 }
29248 {
29249 resultobj = wxPyMake_wxObject(result, 0);
29250 }
29251 return resultobj;
29252 fail:
29253 return NULL;
29254 }
29255
29256
29257 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29258 PyObject *resultobj;
29259 wxWindow *arg1 = (wxWindow *) 0 ;
29260 bool result;
29261 PyObject * obj0 = 0 ;
29262 char *kwnames[] = {
29263 (char *) "self", NULL
29264 };
29265
29266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29268 if (SWIG_arg_fail(1)) SWIG_fail;
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 result = (bool)((wxWindow const *)arg1)->HasCapture();
29272
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 {
29277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29278 }
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29286 PyObject *resultobj;
29287 wxWindow *arg1 = (wxWindow *) 0 ;
29288 bool arg2 = (bool) true ;
29289 wxRect *arg3 = (wxRect *) NULL ;
29290 PyObject * obj0 = 0 ;
29291 PyObject * obj1 = 0 ;
29292 PyObject * obj2 = 0 ;
29293 char *kwnames[] = {
29294 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29295 };
29296
29297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29299 if (SWIG_arg_fail(1)) SWIG_fail;
29300 if (obj1) {
29301 {
29302 arg2 = (bool)(SWIG_As_bool(obj1));
29303 if (SWIG_arg_fail(2)) SWIG_fail;
29304 }
29305 }
29306 if (obj2) {
29307 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29308 if (SWIG_arg_fail(3)) SWIG_fail;
29309 }
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29313
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 Py_INCREF(Py_None); resultobj = Py_None;
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj;
29326 wxWindow *arg1 = (wxWindow *) 0 ;
29327 wxRect *arg2 = 0 ;
29328 bool arg3 = (bool) true ;
29329 wxRect temp2 ;
29330 PyObject * obj0 = 0 ;
29331 PyObject * obj1 = 0 ;
29332 PyObject * obj2 = 0 ;
29333 char *kwnames[] = {
29334 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29335 };
29336
29337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29339 if (SWIG_arg_fail(1)) SWIG_fail;
29340 {
29341 arg2 = &temp2;
29342 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29343 }
29344 if (obj2) {
29345 {
29346 arg3 = (bool)(SWIG_As_bool(obj2));
29347 if (SWIG_arg_fail(3)) SWIG_fail;
29348 }
29349 }
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29353
29354 wxPyEndAllowThreads(__tstate);
29355 if (PyErr_Occurred()) SWIG_fail;
29356 }
29357 Py_INCREF(Py_None); resultobj = Py_None;
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29365 PyObject *resultobj;
29366 wxWindow *arg1 = (wxWindow *) 0 ;
29367 PyObject * obj0 = 0 ;
29368 char *kwnames[] = {
29369 (char *) "self", NULL
29370 };
29371
29372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29374 if (SWIG_arg_fail(1)) SWIG_fail;
29375 {
29376 PyThreadState* __tstate = wxPyBeginAllowThreads();
29377 (arg1)->Update();
29378
29379 wxPyEndAllowThreads(__tstate);
29380 if (PyErr_Occurred()) SWIG_fail;
29381 }
29382 Py_INCREF(Py_None); resultobj = Py_None;
29383 return resultobj;
29384 fail:
29385 return NULL;
29386 }
29387
29388
29389 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29390 PyObject *resultobj;
29391 wxWindow *arg1 = (wxWindow *) 0 ;
29392 PyObject * obj0 = 0 ;
29393 char *kwnames[] = {
29394 (char *) "self", NULL
29395 };
29396
29397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29399 if (SWIG_arg_fail(1)) SWIG_fail;
29400 {
29401 PyThreadState* __tstate = wxPyBeginAllowThreads();
29402 (arg1)->ClearBackground();
29403
29404 wxPyEndAllowThreads(__tstate);
29405 if (PyErr_Occurred()) SWIG_fail;
29406 }
29407 Py_INCREF(Py_None); resultobj = Py_None;
29408 return resultobj;
29409 fail:
29410 return NULL;
29411 }
29412
29413
29414 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29415 PyObject *resultobj;
29416 wxWindow *arg1 = (wxWindow *) 0 ;
29417 PyObject * obj0 = 0 ;
29418 char *kwnames[] = {
29419 (char *) "self", NULL
29420 };
29421
29422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29424 if (SWIG_arg_fail(1)) SWIG_fail;
29425 {
29426 PyThreadState* __tstate = wxPyBeginAllowThreads();
29427 (arg1)->Freeze();
29428
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 Py_INCREF(Py_None); resultobj = Py_None;
29433 return resultobj;
29434 fail:
29435 return NULL;
29436 }
29437
29438
29439 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29440 PyObject *resultobj;
29441 wxWindow *arg1 = (wxWindow *) 0 ;
29442 PyObject * obj0 = 0 ;
29443 char *kwnames[] = {
29444 (char *) "self", NULL
29445 };
29446
29447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29449 if (SWIG_arg_fail(1)) SWIG_fail;
29450 {
29451 PyThreadState* __tstate = wxPyBeginAllowThreads();
29452 (arg1)->Thaw();
29453
29454 wxPyEndAllowThreads(__tstate);
29455 if (PyErr_Occurred()) SWIG_fail;
29456 }
29457 Py_INCREF(Py_None); resultobj = Py_None;
29458 return resultobj;
29459 fail:
29460 return NULL;
29461 }
29462
29463
29464 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29465 PyObject *resultobj;
29466 wxWindow *arg1 = (wxWindow *) 0 ;
29467 wxDC *arg2 = 0 ;
29468 PyObject * obj0 = 0 ;
29469 PyObject * obj1 = 0 ;
29470 char *kwnames[] = {
29471 (char *) "self",(char *) "dc", NULL
29472 };
29473
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29476 if (SWIG_arg_fail(1)) SWIG_fail;
29477 {
29478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29479 if (SWIG_arg_fail(2)) SWIG_fail;
29480 if (arg2 == NULL) {
29481 SWIG_null_ref("wxDC");
29482 }
29483 if (SWIG_arg_fail(2)) SWIG_fail;
29484 }
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 (arg1)->PrepareDC(*arg2);
29488
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 Py_INCREF(Py_None); resultobj = Py_None;
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29500 PyObject *resultobj;
29501 wxWindow *arg1 = (wxWindow *) 0 ;
29502 wxRegion *result;
29503 PyObject * obj0 = 0 ;
29504 char *kwnames[] = {
29505 (char *) "self", NULL
29506 };
29507
29508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",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 {
29514 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29515 result = (wxRegion *) &_result_ref;
29516 }
29517
29518 wxPyEndAllowThreads(__tstate);
29519 if (PyErr_Occurred()) SWIG_fail;
29520 }
29521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29522 return resultobj;
29523 fail:
29524 return NULL;
29525 }
29526
29527
29528 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29529 PyObject *resultobj;
29530 wxWindow *arg1 = (wxWindow *) 0 ;
29531 wxRect result;
29532 PyObject * obj0 = 0 ;
29533 char *kwnames[] = {
29534 (char *) "self", NULL
29535 };
29536
29537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29539 if (SWIG_arg_fail(1)) SWIG_fail;
29540 {
29541 PyThreadState* __tstate = wxPyBeginAllowThreads();
29542 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29543
29544 wxPyEndAllowThreads(__tstate);
29545 if (PyErr_Occurred()) SWIG_fail;
29546 }
29547 {
29548 wxRect * resultptr;
29549 resultptr = new wxRect((wxRect &)(result));
29550 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29551 }
29552 return resultobj;
29553 fail:
29554 return NULL;
29555 }
29556
29557
29558 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29559 PyObject *resultobj;
29560 wxWindow *arg1 = (wxWindow *) 0 ;
29561 int arg2 ;
29562 int arg3 ;
29563 int arg4 = (int) 1 ;
29564 int arg5 = (int) 1 ;
29565 bool result;
29566 PyObject * obj0 = 0 ;
29567 PyObject * obj1 = 0 ;
29568 PyObject * obj2 = 0 ;
29569 PyObject * obj3 = 0 ;
29570 PyObject * obj4 = 0 ;
29571 char *kwnames[] = {
29572 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29573 };
29574
29575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29577 if (SWIG_arg_fail(1)) SWIG_fail;
29578 {
29579 arg2 = (int)(SWIG_As_int(obj1));
29580 if (SWIG_arg_fail(2)) SWIG_fail;
29581 }
29582 {
29583 arg3 = (int)(SWIG_As_int(obj2));
29584 if (SWIG_arg_fail(3)) SWIG_fail;
29585 }
29586 if (obj3) {
29587 {
29588 arg4 = (int)(SWIG_As_int(obj3));
29589 if (SWIG_arg_fail(4)) SWIG_fail;
29590 }
29591 }
29592 if (obj4) {
29593 {
29594 arg5 = (int)(SWIG_As_int(obj4));
29595 if (SWIG_arg_fail(5)) SWIG_fail;
29596 }
29597 }
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 {
29606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29607 }
29608 return resultobj;
29609 fail:
29610 return NULL;
29611 }
29612
29613
29614 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj;
29616 wxWindow *arg1 = (wxWindow *) 0 ;
29617 wxPoint *arg2 = 0 ;
29618 bool result;
29619 wxPoint temp2 ;
29620 PyObject * obj0 = 0 ;
29621 PyObject * obj1 = 0 ;
29622 char *kwnames[] = {
29623 (char *) "self",(char *) "pt", NULL
29624 };
29625
29626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29628 if (SWIG_arg_fail(1)) SWIG_fail;
29629 {
29630 arg2 = &temp2;
29631 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29632 }
29633 {
29634 PyThreadState* __tstate = wxPyBeginAllowThreads();
29635 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29636
29637 wxPyEndAllowThreads(__tstate);
29638 if (PyErr_Occurred()) SWIG_fail;
29639 }
29640 {
29641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29642 }
29643 return resultobj;
29644 fail:
29645 return NULL;
29646 }
29647
29648
29649 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29650 PyObject *resultobj;
29651 wxWindow *arg1 = (wxWindow *) 0 ;
29652 wxRect *arg2 = 0 ;
29653 bool result;
29654 wxRect temp2 ;
29655 PyObject * obj0 = 0 ;
29656 PyObject * obj1 = 0 ;
29657 char *kwnames[] = {
29658 (char *) "self",(char *) "rect", NULL
29659 };
29660
29661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29663 if (SWIG_arg_fail(1)) SWIG_fail;
29664 {
29665 arg2 = &temp2;
29666 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29667 }
29668 {
29669 PyThreadState* __tstate = wxPyBeginAllowThreads();
29670 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29671
29672 wxPyEndAllowThreads(__tstate);
29673 if (PyErr_Occurred()) SWIG_fail;
29674 }
29675 {
29676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29677 }
29678 return resultobj;
29679 fail:
29680 return NULL;
29681 }
29682
29683
29684 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29685 PyObject *resultobj;
29686 wxWindow *arg1 = (wxWindow *) 0 ;
29687 wxVisualAttributes result;
29688 PyObject * obj0 = 0 ;
29689 char *kwnames[] = {
29690 (char *) "self", NULL
29691 };
29692
29693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29695 if (SWIG_arg_fail(1)) SWIG_fail;
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29699
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 {
29704 wxVisualAttributes * resultptr;
29705 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29706 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29707 }
29708 return resultobj;
29709 fail:
29710 return NULL;
29711 }
29712
29713
29714 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29715 PyObject *resultobj;
29716 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29717 wxVisualAttributes result;
29718 PyObject * obj0 = 0 ;
29719 char *kwnames[] = {
29720 (char *) "variant", NULL
29721 };
29722
29723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29724 if (obj0) {
29725 {
29726 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29727 if (SWIG_arg_fail(1)) SWIG_fail;
29728 }
29729 }
29730 {
29731 if (!wxPyCheckForApp()) SWIG_fail;
29732 PyThreadState* __tstate = wxPyBeginAllowThreads();
29733 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29734
29735 wxPyEndAllowThreads(__tstate);
29736 if (PyErr_Occurred()) SWIG_fail;
29737 }
29738 {
29739 wxVisualAttributes * resultptr;
29740 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29741 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29742 }
29743 return resultobj;
29744 fail:
29745 return NULL;
29746 }
29747
29748
29749 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29750 PyObject *resultobj;
29751 wxWindow *arg1 = (wxWindow *) 0 ;
29752 wxColour *arg2 = 0 ;
29753 bool result;
29754 wxColour temp2 ;
29755 PyObject * obj0 = 0 ;
29756 PyObject * obj1 = 0 ;
29757 char *kwnames[] = {
29758 (char *) "self",(char *) "colour", NULL
29759 };
29760
29761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29763 if (SWIG_arg_fail(1)) SWIG_fail;
29764 {
29765 arg2 = &temp2;
29766 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29767 }
29768 {
29769 PyThreadState* __tstate = wxPyBeginAllowThreads();
29770 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29771
29772 wxPyEndAllowThreads(__tstate);
29773 if (PyErr_Occurred()) SWIG_fail;
29774 }
29775 {
29776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29777 }
29778 return resultobj;
29779 fail:
29780 return NULL;
29781 }
29782
29783
29784 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29785 PyObject *resultobj;
29786 wxWindow *arg1 = (wxWindow *) 0 ;
29787 wxColour *arg2 = 0 ;
29788 wxColour temp2 ;
29789 PyObject * obj0 = 0 ;
29790 PyObject * obj1 = 0 ;
29791 char *kwnames[] = {
29792 (char *) "self",(char *) "colour", NULL
29793 };
29794
29795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29797 if (SWIG_arg_fail(1)) SWIG_fail;
29798 {
29799 arg2 = &temp2;
29800 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29801 }
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29805
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 Py_INCREF(Py_None); resultobj = Py_None;
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29817 PyObject *resultobj;
29818 wxWindow *arg1 = (wxWindow *) 0 ;
29819 wxColour *arg2 = 0 ;
29820 bool result;
29821 wxColour temp2 ;
29822 PyObject * obj0 = 0 ;
29823 PyObject * obj1 = 0 ;
29824 char *kwnames[] = {
29825 (char *) "self",(char *) "colour", NULL
29826 };
29827
29828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29830 if (SWIG_arg_fail(1)) SWIG_fail;
29831 {
29832 arg2 = &temp2;
29833 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29834 }
29835 {
29836 PyThreadState* __tstate = wxPyBeginAllowThreads();
29837 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29838
29839 wxPyEndAllowThreads(__tstate);
29840 if (PyErr_Occurred()) SWIG_fail;
29841 }
29842 {
29843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29844 }
29845 return resultobj;
29846 fail:
29847 return NULL;
29848 }
29849
29850
29851 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29852 PyObject *resultobj;
29853 wxWindow *arg1 = (wxWindow *) 0 ;
29854 wxColour *arg2 = 0 ;
29855 wxColour temp2 ;
29856 PyObject * obj0 = 0 ;
29857 PyObject * obj1 = 0 ;
29858 char *kwnames[] = {
29859 (char *) "self",(char *) "colour", NULL
29860 };
29861
29862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29864 if (SWIG_arg_fail(1)) SWIG_fail;
29865 {
29866 arg2 = &temp2;
29867 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29868 }
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29872
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 Py_INCREF(Py_None); resultobj = Py_None;
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj;
29885 wxWindow *arg1 = (wxWindow *) 0 ;
29886 wxColour result;
29887 PyObject * obj0 = 0 ;
29888 char *kwnames[] = {
29889 (char *) "self", NULL
29890 };
29891
29892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29894 if (SWIG_arg_fail(1)) SWIG_fail;
29895 {
29896 PyThreadState* __tstate = wxPyBeginAllowThreads();
29897 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29898
29899 wxPyEndAllowThreads(__tstate);
29900 if (PyErr_Occurred()) SWIG_fail;
29901 }
29902 {
29903 wxColour * resultptr;
29904 resultptr = new wxColour((wxColour &)(result));
29905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29906 }
29907 return resultobj;
29908 fail:
29909 return NULL;
29910 }
29911
29912
29913 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29914 PyObject *resultobj;
29915 wxWindow *arg1 = (wxWindow *) 0 ;
29916 wxColour result;
29917 PyObject * obj0 = 0 ;
29918 char *kwnames[] = {
29919 (char *) "self", NULL
29920 };
29921
29922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29924 if (SWIG_arg_fail(1)) SWIG_fail;
29925 {
29926 PyThreadState* __tstate = wxPyBeginAllowThreads();
29927 result = ((wxWindow const *)arg1)->GetForegroundColour();
29928
29929 wxPyEndAllowThreads(__tstate);
29930 if (PyErr_Occurred()) SWIG_fail;
29931 }
29932 {
29933 wxColour * resultptr;
29934 resultptr = new wxColour((wxColour &)(result));
29935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29936 }
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj;
29945 wxWindow *arg1 = (wxWindow *) 0 ;
29946 bool result;
29947 PyObject * obj0 = 0 ;
29948 char *kwnames[] = {
29949 (char *) "self", NULL
29950 };
29951
29952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29954 if (SWIG_arg_fail(1)) SWIG_fail;
29955 {
29956 PyThreadState* __tstate = wxPyBeginAllowThreads();
29957 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29958
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 {
29963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29964 }
29965 return resultobj;
29966 fail:
29967 return NULL;
29968 }
29969
29970
29971 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29972 PyObject *resultobj;
29973 wxWindow *arg1 = (wxWindow *) 0 ;
29974 bool result;
29975 PyObject * obj0 = 0 ;
29976 char *kwnames[] = {
29977 (char *) "self", NULL
29978 };
29979
29980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29982 if (SWIG_arg_fail(1)) SWIG_fail;
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29986
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 {
29991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29992 }
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30000 PyObject *resultobj;
30001 wxWindow *arg1 = (wxWindow *) 0 ;
30002 wxBackgroundStyle arg2 ;
30003 bool result;
30004 PyObject * obj0 = 0 ;
30005 PyObject * obj1 = 0 ;
30006 char *kwnames[] = {
30007 (char *) "self",(char *) "style", NULL
30008 };
30009
30010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30012 if (SWIG_arg_fail(1)) SWIG_fail;
30013 {
30014 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
30015 if (SWIG_arg_fail(2)) SWIG_fail;
30016 }
30017 {
30018 PyThreadState* __tstate = wxPyBeginAllowThreads();
30019 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30020
30021 wxPyEndAllowThreads(__tstate);
30022 if (PyErr_Occurred()) SWIG_fail;
30023 }
30024 {
30025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30026 }
30027 return resultobj;
30028 fail:
30029 return NULL;
30030 }
30031
30032
30033 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30034 PyObject *resultobj;
30035 wxWindow *arg1 = (wxWindow *) 0 ;
30036 wxBackgroundStyle result;
30037 PyObject * obj0 = 0 ;
30038 char *kwnames[] = {
30039 (char *) "self", NULL
30040 };
30041
30042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30044 if (SWIG_arg_fail(1)) SWIG_fail;
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30048
30049 wxPyEndAllowThreads(__tstate);
30050 if (PyErr_Occurred()) SWIG_fail;
30051 }
30052 resultobj = SWIG_From_int((result));
30053 return resultobj;
30054 fail:
30055 return NULL;
30056 }
30057
30058
30059 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30060 PyObject *resultobj;
30061 wxWindow *arg1 = (wxWindow *) 0 ;
30062 bool result;
30063 PyObject * obj0 = 0 ;
30064 char *kwnames[] = {
30065 (char *) "self", NULL
30066 };
30067
30068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30070 if (SWIG_arg_fail(1)) SWIG_fail;
30071 {
30072 PyThreadState* __tstate = wxPyBeginAllowThreads();
30073 result = (bool)(arg1)->HasTransparentBackground();
30074
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 {
30079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30080 }
30081 return resultobj;
30082 fail:
30083 return NULL;
30084 }
30085
30086
30087 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30088 PyObject *resultobj;
30089 wxWindow *arg1 = (wxWindow *) 0 ;
30090 wxCursor *arg2 = 0 ;
30091 bool result;
30092 PyObject * obj0 = 0 ;
30093 PyObject * obj1 = 0 ;
30094 char *kwnames[] = {
30095 (char *) "self",(char *) "cursor", NULL
30096 };
30097
30098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30100 if (SWIG_arg_fail(1)) SWIG_fail;
30101 {
30102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30103 if (SWIG_arg_fail(2)) SWIG_fail;
30104 if (arg2 == NULL) {
30105 SWIG_null_ref("wxCursor");
30106 }
30107 if (SWIG_arg_fail(2)) SWIG_fail;
30108 }
30109 {
30110 PyThreadState* __tstate = wxPyBeginAllowThreads();
30111 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30112
30113 wxPyEndAllowThreads(__tstate);
30114 if (PyErr_Occurred()) SWIG_fail;
30115 }
30116 {
30117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30118 }
30119 return resultobj;
30120 fail:
30121 return NULL;
30122 }
30123
30124
30125 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30126 PyObject *resultobj;
30127 wxWindow *arg1 = (wxWindow *) 0 ;
30128 wxCursor result;
30129 PyObject * obj0 = 0 ;
30130 char *kwnames[] = {
30131 (char *) "self", NULL
30132 };
30133
30134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30136 if (SWIG_arg_fail(1)) SWIG_fail;
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 result = (arg1)->GetCursor();
30140
30141 wxPyEndAllowThreads(__tstate);
30142 if (PyErr_Occurred()) SWIG_fail;
30143 }
30144 {
30145 wxCursor * resultptr;
30146 resultptr = new wxCursor((wxCursor &)(result));
30147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30148 }
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30156 PyObject *resultobj;
30157 wxWindow *arg1 = (wxWindow *) 0 ;
30158 wxFont *arg2 = 0 ;
30159 bool result;
30160 PyObject * obj0 = 0 ;
30161 PyObject * obj1 = 0 ;
30162 char *kwnames[] = {
30163 (char *) "self",(char *) "font", NULL
30164 };
30165
30166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30168 if (SWIG_arg_fail(1)) SWIG_fail;
30169 {
30170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30171 if (SWIG_arg_fail(2)) SWIG_fail;
30172 if (arg2 == NULL) {
30173 SWIG_null_ref("wxFont");
30174 }
30175 if (SWIG_arg_fail(2)) SWIG_fail;
30176 }
30177 {
30178 PyThreadState* __tstate = wxPyBeginAllowThreads();
30179 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30180
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 {
30185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30186 }
30187 return resultobj;
30188 fail:
30189 return NULL;
30190 }
30191
30192
30193 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30194 PyObject *resultobj;
30195 wxWindow *arg1 = (wxWindow *) 0 ;
30196 wxFont *arg2 = 0 ;
30197 PyObject * obj0 = 0 ;
30198 PyObject * obj1 = 0 ;
30199 char *kwnames[] = {
30200 (char *) "self",(char *) "font", NULL
30201 };
30202
30203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30205 if (SWIG_arg_fail(1)) SWIG_fail;
30206 {
30207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30208 if (SWIG_arg_fail(2)) SWIG_fail;
30209 if (arg2 == NULL) {
30210 SWIG_null_ref("wxFont");
30211 }
30212 if (SWIG_arg_fail(2)) SWIG_fail;
30213 }
30214 {
30215 PyThreadState* __tstate = wxPyBeginAllowThreads();
30216 (arg1)->SetOwnFont((wxFont const &)*arg2);
30217
30218 wxPyEndAllowThreads(__tstate);
30219 if (PyErr_Occurred()) SWIG_fail;
30220 }
30221 Py_INCREF(Py_None); resultobj = Py_None;
30222 return resultobj;
30223 fail:
30224 return NULL;
30225 }
30226
30227
30228 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30229 PyObject *resultobj;
30230 wxWindow *arg1 = (wxWindow *) 0 ;
30231 wxFont result;
30232 PyObject * obj0 = 0 ;
30233 char *kwnames[] = {
30234 (char *) "self", NULL
30235 };
30236
30237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30239 if (SWIG_arg_fail(1)) SWIG_fail;
30240 {
30241 PyThreadState* __tstate = wxPyBeginAllowThreads();
30242 result = (arg1)->GetFont();
30243
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 {
30248 wxFont * resultptr;
30249 resultptr = new wxFont((wxFont &)(result));
30250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30251 }
30252 return resultobj;
30253 fail:
30254 return NULL;
30255 }
30256
30257
30258 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30259 PyObject *resultobj;
30260 wxWindow *arg1 = (wxWindow *) 0 ;
30261 wxCaret *arg2 = (wxCaret *) 0 ;
30262 PyObject * obj0 = 0 ;
30263 PyObject * obj1 = 0 ;
30264 char *kwnames[] = {
30265 (char *) "self",(char *) "caret", NULL
30266 };
30267
30268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(1)) SWIG_fail;
30271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30272 if (SWIG_arg_fail(2)) SWIG_fail;
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 (arg1)->SetCaret(arg2);
30276
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 Py_INCREF(Py_None); resultobj = Py_None;
30281 return resultobj;
30282 fail:
30283 return NULL;
30284 }
30285
30286
30287 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30288 PyObject *resultobj;
30289 wxWindow *arg1 = (wxWindow *) 0 ;
30290 wxCaret *result;
30291 PyObject * obj0 = 0 ;
30292 char *kwnames[] = {
30293 (char *) "self", NULL
30294 };
30295
30296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30298 if (SWIG_arg_fail(1)) SWIG_fail;
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30302
30303 wxPyEndAllowThreads(__tstate);
30304 if (PyErr_Occurred()) SWIG_fail;
30305 }
30306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30314 PyObject *resultobj;
30315 wxWindow *arg1 = (wxWindow *) 0 ;
30316 int result;
30317 PyObject * obj0 = 0 ;
30318 char *kwnames[] = {
30319 (char *) "self", NULL
30320 };
30321
30322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30324 if (SWIG_arg_fail(1)) SWIG_fail;
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30328
30329 wxPyEndAllowThreads(__tstate);
30330 if (PyErr_Occurred()) SWIG_fail;
30331 }
30332 {
30333 resultobj = SWIG_From_int((int)(result));
30334 }
30335 return resultobj;
30336 fail:
30337 return NULL;
30338 }
30339
30340
30341 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj;
30343 wxWindow *arg1 = (wxWindow *) 0 ;
30344 int result;
30345 PyObject * obj0 = 0 ;
30346 char *kwnames[] = {
30347 (char *) "self", NULL
30348 };
30349
30350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",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 = (int)((wxWindow const *)arg1)->GetCharWidth();
30356
30357 wxPyEndAllowThreads(__tstate);
30358 if (PyErr_Occurred()) SWIG_fail;
30359 }
30360 {
30361 resultobj = SWIG_From_int((int)(result));
30362 }
30363 return resultobj;
30364 fail:
30365 return NULL;
30366 }
30367
30368
30369 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30370 PyObject *resultobj;
30371 wxWindow *arg1 = (wxWindow *) 0 ;
30372 wxString *arg2 = 0 ;
30373 int *arg3 = (int *) 0 ;
30374 int *arg4 = (int *) 0 ;
30375 bool temp2 = false ;
30376 int temp3 ;
30377 int res3 = 0 ;
30378 int temp4 ;
30379 int res4 = 0 ;
30380 PyObject * obj0 = 0 ;
30381 PyObject * obj1 = 0 ;
30382 char *kwnames[] = {
30383 (char *) "self",(char *) "string", NULL
30384 };
30385
30386 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30387 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30390 if (SWIG_arg_fail(1)) SWIG_fail;
30391 {
30392 arg2 = wxString_in_helper(obj1);
30393 if (arg2 == NULL) SWIG_fail;
30394 temp2 = true;
30395 }
30396 {
30397 PyThreadState* __tstate = wxPyBeginAllowThreads();
30398 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30399
30400 wxPyEndAllowThreads(__tstate);
30401 if (PyErr_Occurred()) SWIG_fail;
30402 }
30403 Py_INCREF(Py_None); resultobj = Py_None;
30404 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30405 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30406 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30407 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30408 {
30409 if (temp2)
30410 delete arg2;
30411 }
30412 return resultobj;
30413 fail:
30414 {
30415 if (temp2)
30416 delete arg2;
30417 }
30418 return NULL;
30419 }
30420
30421
30422 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30423 PyObject *resultobj;
30424 wxWindow *arg1 = (wxWindow *) 0 ;
30425 wxString *arg2 = 0 ;
30426 int *arg3 = (int *) 0 ;
30427 int *arg4 = (int *) 0 ;
30428 int *arg5 = (int *) 0 ;
30429 int *arg6 = (int *) 0 ;
30430 wxFont *arg7 = (wxFont *) NULL ;
30431 bool temp2 = false ;
30432 int temp3 ;
30433 int res3 = 0 ;
30434 int temp4 ;
30435 int res4 = 0 ;
30436 int temp5 ;
30437 int res5 = 0 ;
30438 int temp6 ;
30439 int res6 = 0 ;
30440 PyObject * obj0 = 0 ;
30441 PyObject * obj1 = 0 ;
30442 PyObject * obj2 = 0 ;
30443 char *kwnames[] = {
30444 (char *) "self",(char *) "string",(char *) "font", NULL
30445 };
30446
30447 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30448 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30449 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30450 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30453 if (SWIG_arg_fail(1)) SWIG_fail;
30454 {
30455 arg2 = wxString_in_helper(obj1);
30456 if (arg2 == NULL) SWIG_fail;
30457 temp2 = true;
30458 }
30459 if (obj2) {
30460 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30461 if (SWIG_arg_fail(7)) SWIG_fail;
30462 }
30463 {
30464 PyThreadState* __tstate = wxPyBeginAllowThreads();
30465 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30466
30467 wxPyEndAllowThreads(__tstate);
30468 if (PyErr_Occurred()) SWIG_fail;
30469 }
30470 Py_INCREF(Py_None); resultobj = Py_None;
30471 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30472 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30473 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30474 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30475 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30476 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30477 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30478 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30479 {
30480 if (temp2)
30481 delete arg2;
30482 }
30483 return resultobj;
30484 fail:
30485 {
30486 if (temp2)
30487 delete arg2;
30488 }
30489 return NULL;
30490 }
30491
30492
30493 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30494 PyObject *resultobj;
30495 wxWindow *arg1 = (wxWindow *) 0 ;
30496 int *arg2 = (int *) 0 ;
30497 int *arg3 = (int *) 0 ;
30498 int temp2 ;
30499 int res2 = 0 ;
30500 int temp3 ;
30501 int res3 = 0 ;
30502 PyObject * obj0 = 0 ;
30503 PyObject * obj1 = 0 ;
30504 PyObject * obj2 = 0 ;
30505 char *kwnames[] = {
30506 (char *) "self",(char *) "x",(char *) "y", NULL
30507 };
30508
30509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30511 if (SWIG_arg_fail(1)) SWIG_fail;
30512 {
30513 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30514 temp2 = SWIG_As_int(obj1);
30515 if (SWIG_arg_fail(2)) SWIG_fail;
30516 arg2 = &temp2;
30517 res2 = SWIG_NEWOBJ;
30518 }
30519 }
30520 {
30521 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30522 temp3 = SWIG_As_int(obj2);
30523 if (SWIG_arg_fail(3)) SWIG_fail;
30524 arg3 = &temp3;
30525 res3 = SWIG_NEWOBJ;
30526 }
30527 }
30528 {
30529 PyThreadState* __tstate = wxPyBeginAllowThreads();
30530 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30531
30532 wxPyEndAllowThreads(__tstate);
30533 if (PyErr_Occurred()) SWIG_fail;
30534 }
30535 Py_INCREF(Py_None); resultobj = Py_None;
30536 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30537 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30538 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30539 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30540 return resultobj;
30541 fail:
30542 return NULL;
30543 }
30544
30545
30546 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30547 PyObject *resultobj;
30548 wxWindow *arg1 = (wxWindow *) 0 ;
30549 int *arg2 = (int *) 0 ;
30550 int *arg3 = (int *) 0 ;
30551 int temp2 ;
30552 int res2 = 0 ;
30553 int temp3 ;
30554 int res3 = 0 ;
30555 PyObject * obj0 = 0 ;
30556 PyObject * obj1 = 0 ;
30557 PyObject * obj2 = 0 ;
30558 char *kwnames[] = {
30559 (char *) "self",(char *) "x",(char *) "y", NULL
30560 };
30561
30562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30564 if (SWIG_arg_fail(1)) SWIG_fail;
30565 {
30566 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30567 temp2 = SWIG_As_int(obj1);
30568 if (SWIG_arg_fail(2)) SWIG_fail;
30569 arg2 = &temp2;
30570 res2 = SWIG_NEWOBJ;
30571 }
30572 }
30573 {
30574 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30575 temp3 = SWIG_As_int(obj2);
30576 if (SWIG_arg_fail(3)) SWIG_fail;
30577 arg3 = &temp3;
30578 res3 = SWIG_NEWOBJ;
30579 }
30580 }
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30584
30585 wxPyEndAllowThreads(__tstate);
30586 if (PyErr_Occurred()) SWIG_fail;
30587 }
30588 Py_INCREF(Py_None); resultobj = Py_None;
30589 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30590 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30591 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30592 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30593 return resultobj;
30594 fail:
30595 return NULL;
30596 }
30597
30598
30599 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30600 PyObject *resultobj;
30601 wxWindow *arg1 = (wxWindow *) 0 ;
30602 wxPoint *arg2 = 0 ;
30603 wxPoint result;
30604 wxPoint temp2 ;
30605 PyObject * obj0 = 0 ;
30606 PyObject * obj1 = 0 ;
30607 char *kwnames[] = {
30608 (char *) "self",(char *) "pt", NULL
30609 };
30610
30611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30613 if (SWIG_arg_fail(1)) SWIG_fail;
30614 {
30615 arg2 = &temp2;
30616 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30617 }
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30621
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 {
30626 wxPoint * resultptr;
30627 resultptr = new wxPoint((wxPoint &)(result));
30628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30629 }
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30637 PyObject *resultobj;
30638 wxWindow *arg1 = (wxWindow *) 0 ;
30639 wxPoint *arg2 = 0 ;
30640 wxPoint result;
30641 wxPoint temp2 ;
30642 PyObject * obj0 = 0 ;
30643 PyObject * obj1 = 0 ;
30644 char *kwnames[] = {
30645 (char *) "self",(char *) "pt", NULL
30646 };
30647
30648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30650 if (SWIG_arg_fail(1)) SWIG_fail;
30651 {
30652 arg2 = &temp2;
30653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30654 }
30655 {
30656 PyThreadState* __tstate = wxPyBeginAllowThreads();
30657 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30658
30659 wxPyEndAllowThreads(__tstate);
30660 if (PyErr_Occurred()) SWIG_fail;
30661 }
30662 {
30663 wxPoint * resultptr;
30664 resultptr = new wxPoint((wxPoint &)(result));
30665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30666 }
30667 return resultobj;
30668 fail:
30669 return NULL;
30670 }
30671
30672
30673 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30674 PyObject *resultobj;
30675 wxWindow *arg1 = (wxWindow *) 0 ;
30676 int arg2 ;
30677 int arg3 ;
30678 wxHitTest result;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 PyObject * obj2 = 0 ;
30682 char *kwnames[] = {
30683 (char *) "self",(char *) "x",(char *) "y", NULL
30684 };
30685
30686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30688 if (SWIG_arg_fail(1)) SWIG_fail;
30689 {
30690 arg2 = (int)(SWIG_As_int(obj1));
30691 if (SWIG_arg_fail(2)) SWIG_fail;
30692 }
30693 {
30694 arg3 = (int)(SWIG_As_int(obj2));
30695 if (SWIG_arg_fail(3)) SWIG_fail;
30696 }
30697 {
30698 PyThreadState* __tstate = wxPyBeginAllowThreads();
30699 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30700
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 resultobj = SWIG_From_int((result));
30705 return resultobj;
30706 fail:
30707 return NULL;
30708 }
30709
30710
30711 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30712 PyObject *resultobj;
30713 wxWindow *arg1 = (wxWindow *) 0 ;
30714 wxPoint *arg2 = 0 ;
30715 wxHitTest result;
30716 wxPoint temp2 ;
30717 PyObject * obj0 = 0 ;
30718 PyObject * obj1 = 0 ;
30719 char *kwnames[] = {
30720 (char *) "self",(char *) "pt", NULL
30721 };
30722
30723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30725 if (SWIG_arg_fail(1)) SWIG_fail;
30726 {
30727 arg2 = &temp2;
30728 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30729 }
30730 {
30731 PyThreadState* __tstate = wxPyBeginAllowThreads();
30732 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30733
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 resultobj = SWIG_From_int((result));
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30745 PyObject *resultobj;
30746 wxWindow *arg1 = (wxWindow *) 0 ;
30747 long arg2 ;
30748 wxBorder result;
30749 PyObject * obj0 = 0 ;
30750 PyObject * obj1 = 0 ;
30751
30752 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&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 = (long)(SWIG_As_long(obj1));
30757 if (SWIG_arg_fail(2)) SWIG_fail;
30758 }
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30762
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 resultobj = SWIG_From_int((result));
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30774 PyObject *resultobj;
30775 wxWindow *arg1 = (wxWindow *) 0 ;
30776 wxBorder result;
30777 PyObject * obj0 = 0 ;
30778
30779 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30781 if (SWIG_arg_fail(1)) SWIG_fail;
30782 {
30783 PyThreadState* __tstate = wxPyBeginAllowThreads();
30784 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30785
30786 wxPyEndAllowThreads(__tstate);
30787 if (PyErr_Occurred()) SWIG_fail;
30788 }
30789 resultobj = SWIG_From_int((result));
30790 return resultobj;
30791 fail:
30792 return NULL;
30793 }
30794
30795
30796 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30797 int argc;
30798 PyObject *argv[3];
30799 int ii;
30800
30801 argc = PyObject_Length(args);
30802 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30803 argv[ii] = PyTuple_GetItem(args,ii);
30804 }
30805 if (argc == 1) {
30806 int _v;
30807 {
30808 void *ptr;
30809 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30810 _v = 0;
30811 PyErr_Clear();
30812 } else {
30813 _v = 1;
30814 }
30815 }
30816 if (_v) {
30817 return _wrap_Window_GetBorder__SWIG_1(self,args);
30818 }
30819 }
30820 if (argc == 2) {
30821 int _v;
30822 {
30823 void *ptr;
30824 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30825 _v = 0;
30826 PyErr_Clear();
30827 } else {
30828 _v = 1;
30829 }
30830 }
30831 if (_v) {
30832 _v = SWIG_Check_long(argv[1]);
30833 if (_v) {
30834 return _wrap_Window_GetBorder__SWIG_0(self,args);
30835 }
30836 }
30837 }
30838
30839 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30840 return NULL;
30841 }
30842
30843
30844 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30845 PyObject *resultobj;
30846 wxWindow *arg1 = (wxWindow *) 0 ;
30847 long arg2 = (long) wxUPDATE_UI_NONE ;
30848 PyObject * obj0 = 0 ;
30849 PyObject * obj1 = 0 ;
30850 char *kwnames[] = {
30851 (char *) "self",(char *) "flags", NULL
30852 };
30853
30854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30856 if (SWIG_arg_fail(1)) SWIG_fail;
30857 if (obj1) {
30858 {
30859 arg2 = (long)(SWIG_As_long(obj1));
30860 if (SWIG_arg_fail(2)) SWIG_fail;
30861 }
30862 }
30863 {
30864 PyThreadState* __tstate = wxPyBeginAllowThreads();
30865 (arg1)->UpdateWindowUI(arg2);
30866
30867 wxPyEndAllowThreads(__tstate);
30868 if (PyErr_Occurred()) SWIG_fail;
30869 }
30870 Py_INCREF(Py_None); resultobj = Py_None;
30871 return resultobj;
30872 fail:
30873 return NULL;
30874 }
30875
30876
30877 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30878 PyObject *resultobj;
30879 wxWindow *arg1 = (wxWindow *) 0 ;
30880 wxMenu *arg2 = (wxMenu *) 0 ;
30881 int arg3 = (int) -1 ;
30882 int arg4 = (int) -1 ;
30883 bool result;
30884 PyObject * obj0 = 0 ;
30885 PyObject * obj1 = 0 ;
30886 PyObject * obj2 = 0 ;
30887 PyObject * obj3 = 0 ;
30888 char *kwnames[] = {
30889 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30890 };
30891
30892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30894 if (SWIG_arg_fail(1)) SWIG_fail;
30895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30896 if (SWIG_arg_fail(2)) SWIG_fail;
30897 if (obj2) {
30898 {
30899 arg3 = (int)(SWIG_As_int(obj2));
30900 if (SWIG_arg_fail(3)) SWIG_fail;
30901 }
30902 }
30903 if (obj3) {
30904 {
30905 arg4 = (int)(SWIG_As_int(obj3));
30906 if (SWIG_arg_fail(4)) SWIG_fail;
30907 }
30908 }
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30912
30913 wxPyEndAllowThreads(__tstate);
30914 if (PyErr_Occurred()) SWIG_fail;
30915 }
30916 {
30917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30918 }
30919 return resultobj;
30920 fail:
30921 return NULL;
30922 }
30923
30924
30925 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30926 PyObject *resultobj;
30927 wxWindow *arg1 = (wxWindow *) 0 ;
30928 wxMenu *arg2 = (wxMenu *) 0 ;
30929 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30930 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30931 bool result;
30932 wxPoint temp3 ;
30933 PyObject * obj0 = 0 ;
30934 PyObject * obj1 = 0 ;
30935 PyObject * obj2 = 0 ;
30936 char *kwnames[] = {
30937 (char *) "self",(char *) "menu",(char *) "pos", NULL
30938 };
30939
30940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30942 if (SWIG_arg_fail(1)) SWIG_fail;
30943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30944 if (SWIG_arg_fail(2)) SWIG_fail;
30945 if (obj2) {
30946 {
30947 arg3 = &temp3;
30948 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30949 }
30950 }
30951 {
30952 PyThreadState* __tstate = wxPyBeginAllowThreads();
30953 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30954
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 {
30959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30960 }
30961 return resultobj;
30962 fail:
30963 return NULL;
30964 }
30965
30966
30967 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30968 PyObject *resultobj;
30969 wxWindow *arg1 = (wxWindow *) 0 ;
30970 long result;
30971 PyObject * obj0 = 0 ;
30972 char *kwnames[] = {
30973 (char *) "self", NULL
30974 };
30975
30976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30978 if (SWIG_arg_fail(1)) SWIG_fail;
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 result = (long)wxWindow_GetHandle(arg1);
30982
30983 wxPyEndAllowThreads(__tstate);
30984 if (PyErr_Occurred()) SWIG_fail;
30985 }
30986 {
30987 resultobj = SWIG_From_long((long)(result));
30988 }
30989 return resultobj;
30990 fail:
30991 return NULL;
30992 }
30993
30994
30995 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30996 PyObject *resultobj;
30997 wxWindow *arg1 = (wxWindow *) 0 ;
30998 long arg2 ;
30999 PyObject * obj0 = 0 ;
31000 PyObject * obj1 = 0 ;
31001 char *kwnames[] = {
31002 (char *) "self",(char *) "handle", NULL
31003 };
31004
31005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31007 if (SWIG_arg_fail(1)) SWIG_fail;
31008 {
31009 arg2 = (long)(SWIG_As_long(obj1));
31010 if (SWIG_arg_fail(2)) SWIG_fail;
31011 }
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 wxWindow_AssociateHandle(arg1,arg2);
31015
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 Py_INCREF(Py_None); resultobj = Py_None;
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31027 PyObject *resultobj;
31028 wxWindow *arg1 = (wxWindow *) 0 ;
31029 PyObject * obj0 = 0 ;
31030 char *kwnames[] = {
31031 (char *) "self", NULL
31032 };
31033
31034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31036 if (SWIG_arg_fail(1)) SWIG_fail;
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 (arg1)->DissociateHandle();
31040
31041 wxPyEndAllowThreads(__tstate);
31042 if (PyErr_Occurred()) SWIG_fail;
31043 }
31044 Py_INCREF(Py_None); resultobj = Py_None;
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj;
31053 wxWindow *arg1 = (wxWindow *) 0 ;
31054 int arg2 ;
31055 bool result;
31056 PyObject * obj0 = 0 ;
31057 PyObject * obj1 = 0 ;
31058 char *kwnames[] = {
31059 (char *) "self",(char *) "orient", NULL
31060 };
31061
31062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31064 if (SWIG_arg_fail(1)) SWIG_fail;
31065 {
31066 arg2 = (int)(SWIG_As_int(obj1));
31067 if (SWIG_arg_fail(2)) SWIG_fail;
31068 }
31069 {
31070 PyThreadState* __tstate = wxPyBeginAllowThreads();
31071 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31072
31073 wxPyEndAllowThreads(__tstate);
31074 if (PyErr_Occurred()) SWIG_fail;
31075 }
31076 {
31077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31078 }
31079 return resultobj;
31080 fail:
31081 return NULL;
31082 }
31083
31084
31085 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31086 PyObject *resultobj;
31087 wxWindow *arg1 = (wxWindow *) 0 ;
31088 int arg2 ;
31089 int arg3 ;
31090 int arg4 ;
31091 int arg5 ;
31092 bool arg6 = (bool) true ;
31093 PyObject * obj0 = 0 ;
31094 PyObject * obj1 = 0 ;
31095 PyObject * obj2 = 0 ;
31096 PyObject * obj3 = 0 ;
31097 PyObject * obj4 = 0 ;
31098 PyObject * obj5 = 0 ;
31099 char *kwnames[] = {
31100 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31101 };
31102
31103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31105 if (SWIG_arg_fail(1)) SWIG_fail;
31106 {
31107 arg2 = (int)(SWIG_As_int(obj1));
31108 if (SWIG_arg_fail(2)) SWIG_fail;
31109 }
31110 {
31111 arg3 = (int)(SWIG_As_int(obj2));
31112 if (SWIG_arg_fail(3)) SWIG_fail;
31113 }
31114 {
31115 arg4 = (int)(SWIG_As_int(obj3));
31116 if (SWIG_arg_fail(4)) SWIG_fail;
31117 }
31118 {
31119 arg5 = (int)(SWIG_As_int(obj4));
31120 if (SWIG_arg_fail(5)) SWIG_fail;
31121 }
31122 if (obj5) {
31123 {
31124 arg6 = (bool)(SWIG_As_bool(obj5));
31125 if (SWIG_arg_fail(6)) SWIG_fail;
31126 }
31127 }
31128 {
31129 PyThreadState* __tstate = wxPyBeginAllowThreads();
31130 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31131
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 Py_INCREF(Py_None); resultobj = Py_None;
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31143 PyObject *resultobj;
31144 wxWindow *arg1 = (wxWindow *) 0 ;
31145 int arg2 ;
31146 int arg3 ;
31147 bool arg4 = (bool) true ;
31148 PyObject * obj0 = 0 ;
31149 PyObject * obj1 = 0 ;
31150 PyObject * obj2 = 0 ;
31151 PyObject * obj3 = 0 ;
31152 char *kwnames[] = {
31153 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31154 };
31155
31156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31158 if (SWIG_arg_fail(1)) SWIG_fail;
31159 {
31160 arg2 = (int)(SWIG_As_int(obj1));
31161 if (SWIG_arg_fail(2)) SWIG_fail;
31162 }
31163 {
31164 arg3 = (int)(SWIG_As_int(obj2));
31165 if (SWIG_arg_fail(3)) SWIG_fail;
31166 }
31167 if (obj3) {
31168 {
31169 arg4 = (bool)(SWIG_As_bool(obj3));
31170 if (SWIG_arg_fail(4)) SWIG_fail;
31171 }
31172 }
31173 {
31174 PyThreadState* __tstate = wxPyBeginAllowThreads();
31175 (arg1)->SetScrollPos(arg2,arg3,arg4);
31176
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 Py_INCREF(Py_None); resultobj = Py_None;
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31188 PyObject *resultobj;
31189 wxWindow *arg1 = (wxWindow *) 0 ;
31190 int arg2 ;
31191 int result;
31192 PyObject * obj0 = 0 ;
31193 PyObject * obj1 = 0 ;
31194 char *kwnames[] = {
31195 (char *) "self",(char *) "orientation", NULL
31196 };
31197
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",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 = (int)(SWIG_As_int(obj1));
31203 if (SWIG_arg_fail(2)) SWIG_fail;
31204 }
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31208
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 {
31213 resultobj = SWIG_From_int((int)(result));
31214 }
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31222 PyObject *resultobj;
31223 wxWindow *arg1 = (wxWindow *) 0 ;
31224 int arg2 ;
31225 int result;
31226 PyObject * obj0 = 0 ;
31227 PyObject * obj1 = 0 ;
31228 char *kwnames[] = {
31229 (char *) "self",(char *) "orientation", NULL
31230 };
31231
31232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31234 if (SWIG_arg_fail(1)) SWIG_fail;
31235 {
31236 arg2 = (int)(SWIG_As_int(obj1));
31237 if (SWIG_arg_fail(2)) SWIG_fail;
31238 }
31239 {
31240 PyThreadState* __tstate = wxPyBeginAllowThreads();
31241 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31242
31243 wxPyEndAllowThreads(__tstate);
31244 if (PyErr_Occurred()) SWIG_fail;
31245 }
31246 {
31247 resultobj = SWIG_From_int((int)(result));
31248 }
31249 return resultobj;
31250 fail:
31251 return NULL;
31252 }
31253
31254
31255 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31256 PyObject *resultobj;
31257 wxWindow *arg1 = (wxWindow *) 0 ;
31258 int arg2 ;
31259 int result;
31260 PyObject * obj0 = 0 ;
31261 PyObject * obj1 = 0 ;
31262 char *kwnames[] = {
31263 (char *) "self",(char *) "orientation", NULL
31264 };
31265
31266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31268 if (SWIG_arg_fail(1)) SWIG_fail;
31269 {
31270 arg2 = (int)(SWIG_As_int(obj1));
31271 if (SWIG_arg_fail(2)) SWIG_fail;
31272 }
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31276
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 {
31281 resultobj = SWIG_From_int((int)(result));
31282 }
31283 return resultobj;
31284 fail:
31285 return NULL;
31286 }
31287
31288
31289 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31290 PyObject *resultobj;
31291 wxWindow *arg1 = (wxWindow *) 0 ;
31292 int arg2 ;
31293 int arg3 ;
31294 wxRect *arg4 = (wxRect *) NULL ;
31295 PyObject * obj0 = 0 ;
31296 PyObject * obj1 = 0 ;
31297 PyObject * obj2 = 0 ;
31298 PyObject * obj3 = 0 ;
31299 char *kwnames[] = {
31300 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31301 };
31302
31303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31305 if (SWIG_arg_fail(1)) SWIG_fail;
31306 {
31307 arg2 = (int)(SWIG_As_int(obj1));
31308 if (SWIG_arg_fail(2)) SWIG_fail;
31309 }
31310 {
31311 arg3 = (int)(SWIG_As_int(obj2));
31312 if (SWIG_arg_fail(3)) SWIG_fail;
31313 }
31314 if (obj3) {
31315 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31316 if (SWIG_arg_fail(4)) SWIG_fail;
31317 }
31318 {
31319 PyThreadState* __tstate = wxPyBeginAllowThreads();
31320 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31321
31322 wxPyEndAllowThreads(__tstate);
31323 if (PyErr_Occurred()) SWIG_fail;
31324 }
31325 Py_INCREF(Py_None); resultobj = Py_None;
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 int arg2 ;
31336 bool result;
31337 PyObject * obj0 = 0 ;
31338 PyObject * obj1 = 0 ;
31339 char *kwnames[] = {
31340 (char *) "self",(char *) "lines", NULL
31341 };
31342
31343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31345 if (SWIG_arg_fail(1)) SWIG_fail;
31346 {
31347 arg2 = (int)(SWIG_As_int(obj1));
31348 if (SWIG_arg_fail(2)) SWIG_fail;
31349 }
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 result = (bool)(arg1)->ScrollLines(arg2);
31353
31354 wxPyEndAllowThreads(__tstate);
31355 if (PyErr_Occurred()) SWIG_fail;
31356 }
31357 {
31358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31359 }
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31367 PyObject *resultobj;
31368 wxWindow *arg1 = (wxWindow *) 0 ;
31369 int arg2 ;
31370 bool result;
31371 PyObject * obj0 = 0 ;
31372 PyObject * obj1 = 0 ;
31373 char *kwnames[] = {
31374 (char *) "self",(char *) "pages", NULL
31375 };
31376
31377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31379 if (SWIG_arg_fail(1)) SWIG_fail;
31380 {
31381 arg2 = (int)(SWIG_As_int(obj1));
31382 if (SWIG_arg_fail(2)) SWIG_fail;
31383 }
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 result = (bool)(arg1)->ScrollPages(arg2);
31387
31388 wxPyEndAllowThreads(__tstate);
31389 if (PyErr_Occurred()) SWIG_fail;
31390 }
31391 {
31392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31393 }
31394 return resultobj;
31395 fail:
31396 return NULL;
31397 }
31398
31399
31400 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31401 PyObject *resultobj;
31402 wxWindow *arg1 = (wxWindow *) 0 ;
31403 bool result;
31404 PyObject * obj0 = 0 ;
31405 char *kwnames[] = {
31406 (char *) "self", NULL
31407 };
31408
31409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31411 if (SWIG_arg_fail(1)) SWIG_fail;
31412 {
31413 PyThreadState* __tstate = wxPyBeginAllowThreads();
31414 result = (bool)(arg1)->LineUp();
31415
31416 wxPyEndAllowThreads(__tstate);
31417 if (PyErr_Occurred()) SWIG_fail;
31418 }
31419 {
31420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31421 }
31422 return resultobj;
31423 fail:
31424 return NULL;
31425 }
31426
31427
31428 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31429 PyObject *resultobj;
31430 wxWindow *arg1 = (wxWindow *) 0 ;
31431 bool result;
31432 PyObject * obj0 = 0 ;
31433 char *kwnames[] = {
31434 (char *) "self", NULL
31435 };
31436
31437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31439 if (SWIG_arg_fail(1)) SWIG_fail;
31440 {
31441 PyThreadState* __tstate = wxPyBeginAllowThreads();
31442 result = (bool)(arg1)->LineDown();
31443
31444 wxPyEndAllowThreads(__tstate);
31445 if (PyErr_Occurred()) SWIG_fail;
31446 }
31447 {
31448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31449 }
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj;
31458 wxWindow *arg1 = (wxWindow *) 0 ;
31459 bool result;
31460 PyObject * obj0 = 0 ;
31461 char *kwnames[] = {
31462 (char *) "self", NULL
31463 };
31464
31465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31467 if (SWIG_arg_fail(1)) SWIG_fail;
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 result = (bool)(arg1)->PageUp();
31471
31472 wxPyEndAllowThreads(__tstate);
31473 if (PyErr_Occurred()) SWIG_fail;
31474 }
31475 {
31476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31477 }
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj;
31486 wxWindow *arg1 = (wxWindow *) 0 ;
31487 bool result;
31488 PyObject * obj0 = 0 ;
31489 char *kwnames[] = {
31490 (char *) "self", NULL
31491 };
31492
31493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31495 if (SWIG_arg_fail(1)) SWIG_fail;
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 result = (bool)(arg1)->PageDown();
31499
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 {
31504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31505 }
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31513 PyObject *resultobj;
31514 wxWindow *arg1 = (wxWindow *) 0 ;
31515 wxString *arg2 = 0 ;
31516 bool temp2 = false ;
31517 PyObject * obj0 = 0 ;
31518 PyObject * obj1 = 0 ;
31519 char *kwnames[] = {
31520 (char *) "self",(char *) "text", NULL
31521 };
31522
31523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31525 if (SWIG_arg_fail(1)) SWIG_fail;
31526 {
31527 arg2 = wxString_in_helper(obj1);
31528 if (arg2 == NULL) SWIG_fail;
31529 temp2 = true;
31530 }
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 (arg1)->SetHelpText((wxString const &)*arg2);
31534
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 Py_INCREF(Py_None); resultobj = Py_None;
31539 {
31540 if (temp2)
31541 delete arg2;
31542 }
31543 return resultobj;
31544 fail:
31545 {
31546 if (temp2)
31547 delete arg2;
31548 }
31549 return NULL;
31550 }
31551
31552
31553 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31554 PyObject *resultobj;
31555 wxWindow *arg1 = (wxWindow *) 0 ;
31556 wxString *arg2 = 0 ;
31557 bool temp2 = false ;
31558 PyObject * obj0 = 0 ;
31559 PyObject * obj1 = 0 ;
31560 char *kwnames[] = {
31561 (char *) "self",(char *) "text", NULL
31562 };
31563
31564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31566 if (SWIG_arg_fail(1)) SWIG_fail;
31567 {
31568 arg2 = wxString_in_helper(obj1);
31569 if (arg2 == NULL) SWIG_fail;
31570 temp2 = true;
31571 }
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31575
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 Py_INCREF(Py_None); resultobj = Py_None;
31580 {
31581 if (temp2)
31582 delete arg2;
31583 }
31584 return resultobj;
31585 fail:
31586 {
31587 if (temp2)
31588 delete arg2;
31589 }
31590 return NULL;
31591 }
31592
31593
31594 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31595 PyObject *resultobj;
31596 wxWindow *arg1 = (wxWindow *) 0 ;
31597 wxString result;
31598 PyObject * obj0 = 0 ;
31599 char *kwnames[] = {
31600 (char *) "self", NULL
31601 };
31602
31603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31605 if (SWIG_arg_fail(1)) SWIG_fail;
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 result = ((wxWindow const *)arg1)->GetHelpText();
31609
31610 wxPyEndAllowThreads(__tstate);
31611 if (PyErr_Occurred()) SWIG_fail;
31612 }
31613 {
31614 #if wxUSE_UNICODE
31615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31616 #else
31617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31618 #endif
31619 }
31620 return resultobj;
31621 fail:
31622 return NULL;
31623 }
31624
31625
31626 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31627 PyObject *resultobj;
31628 wxWindow *arg1 = (wxWindow *) 0 ;
31629 wxString *arg2 = 0 ;
31630 bool temp2 = false ;
31631 PyObject * obj0 = 0 ;
31632 PyObject * obj1 = 0 ;
31633 char *kwnames[] = {
31634 (char *) "self",(char *) "tip", NULL
31635 };
31636
31637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31639 if (SWIG_arg_fail(1)) SWIG_fail;
31640 {
31641 arg2 = wxString_in_helper(obj1);
31642 if (arg2 == NULL) SWIG_fail;
31643 temp2 = true;
31644 }
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 (arg1)->SetToolTip((wxString const &)*arg2);
31648
31649 wxPyEndAllowThreads(__tstate);
31650 if (PyErr_Occurred()) SWIG_fail;
31651 }
31652 Py_INCREF(Py_None); resultobj = Py_None;
31653 {
31654 if (temp2)
31655 delete arg2;
31656 }
31657 return resultobj;
31658 fail:
31659 {
31660 if (temp2)
31661 delete arg2;
31662 }
31663 return NULL;
31664 }
31665
31666
31667 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31668 PyObject *resultobj;
31669 wxWindow *arg1 = (wxWindow *) 0 ;
31670 wxToolTip *arg2 = (wxToolTip *) 0 ;
31671 PyObject * obj0 = 0 ;
31672 PyObject * obj1 = 0 ;
31673 char *kwnames[] = {
31674 (char *) "self",(char *) "tip", NULL
31675 };
31676
31677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31679 if (SWIG_arg_fail(1)) SWIG_fail;
31680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31681 if (SWIG_arg_fail(2)) SWIG_fail;
31682 {
31683 PyThreadState* __tstate = wxPyBeginAllowThreads();
31684 (arg1)->SetToolTip(arg2);
31685
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 Py_INCREF(Py_None); resultobj = Py_None;
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31697 PyObject *resultobj;
31698 wxWindow *arg1 = (wxWindow *) 0 ;
31699 wxToolTip *result;
31700 PyObject * obj0 = 0 ;
31701 char *kwnames[] = {
31702 (char *) "self", NULL
31703 };
31704
31705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31707 if (SWIG_arg_fail(1)) SWIG_fail;
31708 {
31709 PyThreadState* __tstate = wxPyBeginAllowThreads();
31710 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31711
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 {
31716 resultobj = wxPyMake_wxObject(result, 0);
31717 }
31718 return resultobj;
31719 fail:
31720 return NULL;
31721 }
31722
31723
31724 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31725 PyObject *resultobj;
31726 wxWindow *arg1 = (wxWindow *) 0 ;
31727 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31728 PyObject * obj0 = 0 ;
31729 PyObject * obj1 = 0 ;
31730 char *kwnames[] = {
31731 (char *) "self",(char *) "dropTarget", NULL
31732 };
31733
31734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31736 if (SWIG_arg_fail(1)) SWIG_fail;
31737 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31738 if (SWIG_arg_fail(2)) SWIG_fail;
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 (arg1)->SetDropTarget(arg2);
31742
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 Py_INCREF(Py_None); resultobj = Py_None;
31747 return resultobj;
31748 fail:
31749 return NULL;
31750 }
31751
31752
31753 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31754 PyObject *resultobj;
31755 wxWindow *arg1 = (wxWindow *) 0 ;
31756 wxPyDropTarget *result;
31757 PyObject * obj0 = 0 ;
31758 char *kwnames[] = {
31759 (char *) "self", NULL
31760 };
31761
31762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31764 if (SWIG_arg_fail(1)) SWIG_fail;
31765 {
31766 PyThreadState* __tstate = wxPyBeginAllowThreads();
31767 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31768
31769 wxPyEndAllowThreads(__tstate);
31770 if (PyErr_Occurred()) SWIG_fail;
31771 }
31772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31773 return resultobj;
31774 fail:
31775 return NULL;
31776 }
31777
31778
31779 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31780 PyObject *resultobj;
31781 wxWindow *arg1 = (wxWindow *) 0 ;
31782 bool arg2 ;
31783 PyObject * obj0 = 0 ;
31784 PyObject * obj1 = 0 ;
31785 char *kwnames[] = {
31786 (char *) "self",(char *) "accept", NULL
31787 };
31788
31789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31791 if (SWIG_arg_fail(1)) SWIG_fail;
31792 {
31793 arg2 = (bool)(SWIG_As_bool(obj1));
31794 if (SWIG_arg_fail(2)) SWIG_fail;
31795 }
31796 {
31797 PyThreadState* __tstate = wxPyBeginAllowThreads();
31798 wxWindow_DragAcceptFiles(arg1,arg2);
31799
31800 wxPyEndAllowThreads(__tstate);
31801 if (PyErr_Occurred()) SWIG_fail;
31802 }
31803 Py_INCREF(Py_None); resultobj = Py_None;
31804 return resultobj;
31805 fail:
31806 return NULL;
31807 }
31808
31809
31810 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31811 PyObject *resultobj;
31812 wxWindow *arg1 = (wxWindow *) 0 ;
31813 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31814 PyObject * obj0 = 0 ;
31815 PyObject * obj1 = 0 ;
31816 char *kwnames[] = {
31817 (char *) "self",(char *) "constraints", NULL
31818 };
31819
31820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31822 if (SWIG_arg_fail(1)) SWIG_fail;
31823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31824 if (SWIG_arg_fail(2)) SWIG_fail;
31825 {
31826 PyThreadState* __tstate = wxPyBeginAllowThreads();
31827 (arg1)->SetConstraints(arg2);
31828
31829 wxPyEndAllowThreads(__tstate);
31830 if (PyErr_Occurred()) SWIG_fail;
31831 }
31832 Py_INCREF(Py_None); resultobj = Py_None;
31833 return resultobj;
31834 fail:
31835 return NULL;
31836 }
31837
31838
31839 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31840 PyObject *resultobj;
31841 wxWindow *arg1 = (wxWindow *) 0 ;
31842 wxLayoutConstraints *result;
31843 PyObject * obj0 = 0 ;
31844 char *kwnames[] = {
31845 (char *) "self", NULL
31846 };
31847
31848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31850 if (SWIG_arg_fail(1)) SWIG_fail;
31851 {
31852 PyThreadState* __tstate = wxPyBeginAllowThreads();
31853 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31854
31855 wxPyEndAllowThreads(__tstate);
31856 if (PyErr_Occurred()) SWIG_fail;
31857 }
31858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31859 return resultobj;
31860 fail:
31861 return NULL;
31862 }
31863
31864
31865 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31866 PyObject *resultobj;
31867 wxWindow *arg1 = (wxWindow *) 0 ;
31868 bool arg2 ;
31869 PyObject * obj0 = 0 ;
31870 PyObject * obj1 = 0 ;
31871 char *kwnames[] = {
31872 (char *) "self",(char *) "autoLayout", NULL
31873 };
31874
31875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31877 if (SWIG_arg_fail(1)) SWIG_fail;
31878 {
31879 arg2 = (bool)(SWIG_As_bool(obj1));
31880 if (SWIG_arg_fail(2)) SWIG_fail;
31881 }
31882 {
31883 PyThreadState* __tstate = wxPyBeginAllowThreads();
31884 (arg1)->SetAutoLayout(arg2);
31885
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 Py_INCREF(Py_None); resultobj = Py_None;
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj;
31898 wxWindow *arg1 = (wxWindow *) 0 ;
31899 bool result;
31900 PyObject * obj0 = 0 ;
31901 char *kwnames[] = {
31902 (char *) "self", NULL
31903 };
31904
31905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31907 if (SWIG_arg_fail(1)) SWIG_fail;
31908 {
31909 PyThreadState* __tstate = wxPyBeginAllowThreads();
31910 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31911
31912 wxPyEndAllowThreads(__tstate);
31913 if (PyErr_Occurred()) SWIG_fail;
31914 }
31915 {
31916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31917 }
31918 return resultobj;
31919 fail:
31920 return NULL;
31921 }
31922
31923
31924 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31925 PyObject *resultobj;
31926 wxWindow *arg1 = (wxWindow *) 0 ;
31927 bool result;
31928 PyObject * obj0 = 0 ;
31929 char *kwnames[] = {
31930 (char *) "self", NULL
31931 };
31932
31933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31935 if (SWIG_arg_fail(1)) SWIG_fail;
31936 {
31937 PyThreadState* __tstate = wxPyBeginAllowThreads();
31938 result = (bool)(arg1)->Layout();
31939
31940 wxPyEndAllowThreads(__tstate);
31941 if (PyErr_Occurred()) SWIG_fail;
31942 }
31943 {
31944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31945 }
31946 return resultobj;
31947 fail:
31948 return NULL;
31949 }
31950
31951
31952 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31953 PyObject *resultobj;
31954 wxWindow *arg1 = (wxWindow *) 0 ;
31955 wxSizer *arg2 = (wxSizer *) 0 ;
31956 bool arg3 = (bool) true ;
31957 PyObject * obj0 = 0 ;
31958 PyObject * obj1 = 0 ;
31959 PyObject * obj2 = 0 ;
31960 char *kwnames[] = {
31961 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31962 };
31963
31964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31966 if (SWIG_arg_fail(1)) SWIG_fail;
31967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31968 if (SWIG_arg_fail(2)) SWIG_fail;
31969 if (obj2) {
31970 {
31971 arg3 = (bool)(SWIG_As_bool(obj2));
31972 if (SWIG_arg_fail(3)) SWIG_fail;
31973 }
31974 }
31975 {
31976 PyThreadState* __tstate = wxPyBeginAllowThreads();
31977 (arg1)->SetSizer(arg2,arg3);
31978
31979 wxPyEndAllowThreads(__tstate);
31980 if (PyErr_Occurred()) SWIG_fail;
31981 }
31982 Py_INCREF(Py_None); resultobj = Py_None;
31983 return resultobj;
31984 fail:
31985 return NULL;
31986 }
31987
31988
31989 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31990 PyObject *resultobj;
31991 wxWindow *arg1 = (wxWindow *) 0 ;
31992 wxSizer *arg2 = (wxSizer *) 0 ;
31993 bool arg3 = (bool) true ;
31994 PyObject * obj0 = 0 ;
31995 PyObject * obj1 = 0 ;
31996 PyObject * obj2 = 0 ;
31997 char *kwnames[] = {
31998 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31999 };
32000
32001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32003 if (SWIG_arg_fail(1)) SWIG_fail;
32004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32005 if (SWIG_arg_fail(2)) SWIG_fail;
32006 if (obj2) {
32007 {
32008 arg3 = (bool)(SWIG_As_bool(obj2));
32009 if (SWIG_arg_fail(3)) SWIG_fail;
32010 }
32011 }
32012 {
32013 PyThreadState* __tstate = wxPyBeginAllowThreads();
32014 (arg1)->SetSizerAndFit(arg2,arg3);
32015
32016 wxPyEndAllowThreads(__tstate);
32017 if (PyErr_Occurred()) SWIG_fail;
32018 }
32019 Py_INCREF(Py_None); resultobj = Py_None;
32020 return resultobj;
32021 fail:
32022 return NULL;
32023 }
32024
32025
32026 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32027 PyObject *resultobj;
32028 wxWindow *arg1 = (wxWindow *) 0 ;
32029 wxSizer *result;
32030 PyObject * obj0 = 0 ;
32031 char *kwnames[] = {
32032 (char *) "self", NULL
32033 };
32034
32035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32037 if (SWIG_arg_fail(1)) SWIG_fail;
32038 {
32039 PyThreadState* __tstate = wxPyBeginAllowThreads();
32040 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32041
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 {
32046 resultobj = wxPyMake_wxObject(result, 0);
32047 }
32048 return resultobj;
32049 fail:
32050 return NULL;
32051 }
32052
32053
32054 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32055 PyObject *resultobj;
32056 wxWindow *arg1 = (wxWindow *) 0 ;
32057 wxSizer *arg2 = (wxSizer *) 0 ;
32058 PyObject * obj0 = 0 ;
32059 PyObject * obj1 = 0 ;
32060 char *kwnames[] = {
32061 (char *) "self",(char *) "sizer", NULL
32062 };
32063
32064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32066 if (SWIG_arg_fail(1)) SWIG_fail;
32067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32068 if (SWIG_arg_fail(2)) SWIG_fail;
32069 {
32070 PyThreadState* __tstate = wxPyBeginAllowThreads();
32071 (arg1)->SetContainingSizer(arg2);
32072
32073 wxPyEndAllowThreads(__tstate);
32074 if (PyErr_Occurred()) SWIG_fail;
32075 }
32076 Py_INCREF(Py_None); resultobj = Py_None;
32077 return resultobj;
32078 fail:
32079 return NULL;
32080 }
32081
32082
32083 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32084 PyObject *resultobj;
32085 wxWindow *arg1 = (wxWindow *) 0 ;
32086 wxSizer *result;
32087 PyObject * obj0 = 0 ;
32088 char *kwnames[] = {
32089 (char *) "self", NULL
32090 };
32091
32092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32094 if (SWIG_arg_fail(1)) SWIG_fail;
32095 {
32096 PyThreadState* __tstate = wxPyBeginAllowThreads();
32097 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32098
32099 wxPyEndAllowThreads(__tstate);
32100 if (PyErr_Occurred()) SWIG_fail;
32101 }
32102 {
32103 resultobj = wxPyMake_wxObject(result, 0);
32104 }
32105 return resultobj;
32106 fail:
32107 return NULL;
32108 }
32109
32110
32111 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32112 PyObject *resultobj;
32113 wxWindow *arg1 = (wxWindow *) 0 ;
32114 PyObject * obj0 = 0 ;
32115 char *kwnames[] = {
32116 (char *) "self", NULL
32117 };
32118
32119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32121 if (SWIG_arg_fail(1)) SWIG_fail;
32122 {
32123 PyThreadState* __tstate = wxPyBeginAllowThreads();
32124 (arg1)->InheritAttributes();
32125
32126 wxPyEndAllowThreads(__tstate);
32127 if (PyErr_Occurred()) SWIG_fail;
32128 }
32129 Py_INCREF(Py_None); resultobj = Py_None;
32130 return resultobj;
32131 fail:
32132 return NULL;
32133 }
32134
32135
32136 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32137 PyObject *resultobj;
32138 wxWindow *arg1 = (wxWindow *) 0 ;
32139 bool result;
32140 PyObject * obj0 = 0 ;
32141 char *kwnames[] = {
32142 (char *) "self", NULL
32143 };
32144
32145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32147 if (SWIG_arg_fail(1)) SWIG_fail;
32148 {
32149 PyThreadState* __tstate = wxPyBeginAllowThreads();
32150 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32151
32152 wxPyEndAllowThreads(__tstate);
32153 if (PyErr_Occurred()) SWIG_fail;
32154 }
32155 {
32156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32157 }
32158 return resultobj;
32159 fail:
32160 return NULL;
32161 }
32162
32163
32164 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32165 PyObject *obj;
32166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32167 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32168 Py_INCREF(obj);
32169 return Py_BuildValue((char *)"");
32170 }
32171 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32172 PyObject *resultobj;
32173 long arg1 ;
32174 wxWindow *arg2 = (wxWindow *) NULL ;
32175 wxWindow *result;
32176 PyObject * obj0 = 0 ;
32177 PyObject * obj1 = 0 ;
32178 char *kwnames[] = {
32179 (char *) "id",(char *) "parent", NULL
32180 };
32181
32182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32183 {
32184 arg1 = (long)(SWIG_As_long(obj0));
32185 if (SWIG_arg_fail(1)) SWIG_fail;
32186 }
32187 if (obj1) {
32188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32189 if (SWIG_arg_fail(2)) SWIG_fail;
32190 }
32191 {
32192 if (!wxPyCheckForApp()) SWIG_fail;
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32195
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 {
32200 resultobj = wxPyMake_wxObject(result, 0);
32201 }
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32209 PyObject *resultobj;
32210 wxString *arg1 = 0 ;
32211 wxWindow *arg2 = (wxWindow *) NULL ;
32212 wxWindow *result;
32213 bool temp1 = false ;
32214 PyObject * obj0 = 0 ;
32215 PyObject * obj1 = 0 ;
32216 char *kwnames[] = {
32217 (char *) "name",(char *) "parent", NULL
32218 };
32219
32220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32221 {
32222 arg1 = wxString_in_helper(obj0);
32223 if (arg1 == NULL) SWIG_fail;
32224 temp1 = true;
32225 }
32226 if (obj1) {
32227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32228 if (SWIG_arg_fail(2)) SWIG_fail;
32229 }
32230 {
32231 if (!wxPyCheckForApp()) SWIG_fail;
32232 PyThreadState* __tstate = wxPyBeginAllowThreads();
32233 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32234
32235 wxPyEndAllowThreads(__tstate);
32236 if (PyErr_Occurred()) SWIG_fail;
32237 }
32238 {
32239 resultobj = wxPyMake_wxObject(result, 0);
32240 }
32241 {
32242 if (temp1)
32243 delete arg1;
32244 }
32245 return resultobj;
32246 fail:
32247 {
32248 if (temp1)
32249 delete arg1;
32250 }
32251 return NULL;
32252 }
32253
32254
32255 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32256 PyObject *resultobj;
32257 wxString *arg1 = 0 ;
32258 wxWindow *arg2 = (wxWindow *) NULL ;
32259 wxWindow *result;
32260 bool temp1 = false ;
32261 PyObject * obj0 = 0 ;
32262 PyObject * obj1 = 0 ;
32263 char *kwnames[] = {
32264 (char *) "label",(char *) "parent", NULL
32265 };
32266
32267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32268 {
32269 arg1 = wxString_in_helper(obj0);
32270 if (arg1 == NULL) SWIG_fail;
32271 temp1 = true;
32272 }
32273 if (obj1) {
32274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32275 if (SWIG_arg_fail(2)) SWIG_fail;
32276 }
32277 {
32278 if (!wxPyCheckForApp()) SWIG_fail;
32279 PyThreadState* __tstate = wxPyBeginAllowThreads();
32280 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32281
32282 wxPyEndAllowThreads(__tstate);
32283 if (PyErr_Occurred()) SWIG_fail;
32284 }
32285 {
32286 resultobj = wxPyMake_wxObject(result, 0);
32287 }
32288 {
32289 if (temp1)
32290 delete arg1;
32291 }
32292 return resultobj;
32293 fail:
32294 {
32295 if (temp1)
32296 delete arg1;
32297 }
32298 return NULL;
32299 }
32300
32301
32302 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32303 PyObject *resultobj;
32304 wxWindow *arg1 = (wxWindow *) 0 ;
32305 unsigned long arg2 ;
32306 wxWindow *result;
32307 PyObject * obj0 = 0 ;
32308 PyObject * obj1 = 0 ;
32309 char *kwnames[] = {
32310 (char *) "parent",(char *) "_hWnd", NULL
32311 };
32312
32313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32315 if (SWIG_arg_fail(1)) SWIG_fail;
32316 {
32317 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32318 if (SWIG_arg_fail(2)) SWIG_fail;
32319 }
32320 {
32321 PyThreadState* __tstate = wxPyBeginAllowThreads();
32322 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32323
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 {
32328 resultobj = wxPyMake_wxObject(result, 0);
32329 }
32330 return resultobj;
32331 fail:
32332 return NULL;
32333 }
32334
32335
32336 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32337 PyObject *resultobj;
32338 PyObject *result;
32339 char *kwnames[] = {
32340 NULL
32341 };
32342
32343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 result = (PyObject *)GetTopLevelWindows();
32347
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = result;
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32359 PyObject *resultobj;
32360 wxValidator *result;
32361 char *kwnames[] = {
32362 NULL
32363 };
32364
32365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 result = (wxValidator *)new wxValidator();
32369
32370 wxPyEndAllowThreads(__tstate);
32371 if (PyErr_Occurred()) SWIG_fail;
32372 }
32373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32374 return resultobj;
32375 fail:
32376 return NULL;
32377 }
32378
32379
32380 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32381 PyObject *resultobj;
32382 wxValidator *arg1 = (wxValidator *) 0 ;
32383 wxValidator *result;
32384 PyObject * obj0 = 0 ;
32385 char *kwnames[] = {
32386 (char *) "self", NULL
32387 };
32388
32389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32391 if (SWIG_arg_fail(1)) SWIG_fail;
32392 {
32393 PyThreadState* __tstate = wxPyBeginAllowThreads();
32394 result = (wxValidator *)(arg1)->Clone();
32395
32396 wxPyEndAllowThreads(__tstate);
32397 if (PyErr_Occurred()) SWIG_fail;
32398 }
32399 {
32400 resultobj = wxPyMake_wxObject(result, 0);
32401 }
32402 return resultobj;
32403 fail:
32404 return NULL;
32405 }
32406
32407
32408 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32409 PyObject *resultobj;
32410 wxValidator *arg1 = (wxValidator *) 0 ;
32411 wxWindow *arg2 = (wxWindow *) 0 ;
32412 bool result;
32413 PyObject * obj0 = 0 ;
32414 PyObject * obj1 = 0 ;
32415 char *kwnames[] = {
32416 (char *) "self",(char *) "parent", NULL
32417 };
32418
32419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32421 if (SWIG_arg_fail(1)) SWIG_fail;
32422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32423 if (SWIG_arg_fail(2)) SWIG_fail;
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = (bool)(arg1)->Validate(arg2);
32427
32428 wxPyEndAllowThreads(__tstate);
32429 if (PyErr_Occurred()) SWIG_fail;
32430 }
32431 {
32432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32433 }
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32441 PyObject *resultobj;
32442 wxValidator *arg1 = (wxValidator *) 0 ;
32443 bool result;
32444 PyObject * obj0 = 0 ;
32445 char *kwnames[] = {
32446 (char *) "self", NULL
32447 };
32448
32449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32451 if (SWIG_arg_fail(1)) SWIG_fail;
32452 {
32453 PyThreadState* __tstate = wxPyBeginAllowThreads();
32454 result = (bool)(arg1)->TransferToWindow();
32455
32456 wxPyEndAllowThreads(__tstate);
32457 if (PyErr_Occurred()) SWIG_fail;
32458 }
32459 {
32460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32461 }
32462 return resultobj;
32463 fail:
32464 return NULL;
32465 }
32466
32467
32468 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32469 PyObject *resultobj;
32470 wxValidator *arg1 = (wxValidator *) 0 ;
32471 bool result;
32472 PyObject * obj0 = 0 ;
32473 char *kwnames[] = {
32474 (char *) "self", NULL
32475 };
32476
32477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32479 if (SWIG_arg_fail(1)) SWIG_fail;
32480 {
32481 PyThreadState* __tstate = wxPyBeginAllowThreads();
32482 result = (bool)(arg1)->TransferFromWindow();
32483
32484 wxPyEndAllowThreads(__tstate);
32485 if (PyErr_Occurred()) SWIG_fail;
32486 }
32487 {
32488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32489 }
32490 return resultobj;
32491 fail:
32492 return NULL;
32493 }
32494
32495
32496 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32497 PyObject *resultobj;
32498 wxValidator *arg1 = (wxValidator *) 0 ;
32499 wxWindow *result;
32500 PyObject * obj0 = 0 ;
32501 char *kwnames[] = {
32502 (char *) "self", NULL
32503 };
32504
32505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32507 if (SWIG_arg_fail(1)) SWIG_fail;
32508 {
32509 PyThreadState* __tstate = wxPyBeginAllowThreads();
32510 result = (wxWindow *)(arg1)->GetWindow();
32511
32512 wxPyEndAllowThreads(__tstate);
32513 if (PyErr_Occurred()) SWIG_fail;
32514 }
32515 {
32516 resultobj = wxPyMake_wxObject(result, 0);
32517 }
32518 return resultobj;
32519 fail:
32520 return NULL;
32521 }
32522
32523
32524 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32525 PyObject *resultobj;
32526 wxValidator *arg1 = (wxValidator *) 0 ;
32527 wxWindow *arg2 = (wxWindow *) 0 ;
32528 PyObject * obj0 = 0 ;
32529 PyObject * obj1 = 0 ;
32530 char *kwnames[] = {
32531 (char *) "self",(char *) "window", NULL
32532 };
32533
32534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32536 if (SWIG_arg_fail(1)) SWIG_fail;
32537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32538 if (SWIG_arg_fail(2)) SWIG_fail;
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 (arg1)->SetWindow(arg2);
32542
32543 wxPyEndAllowThreads(__tstate);
32544 if (PyErr_Occurred()) SWIG_fail;
32545 }
32546 Py_INCREF(Py_None); resultobj = Py_None;
32547 return resultobj;
32548 fail:
32549 return NULL;
32550 }
32551
32552
32553 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32554 PyObject *resultobj;
32555 bool result;
32556 char *kwnames[] = {
32557 NULL
32558 };
32559
32560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 result = (bool)wxValidator::IsSilent();
32564
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 {
32569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32570 }
32571 return resultobj;
32572 fail:
32573 return NULL;
32574 }
32575
32576
32577 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32578 PyObject *resultobj;
32579 int arg1 = (int) true ;
32580 PyObject * obj0 = 0 ;
32581 char *kwnames[] = {
32582 (char *) "doIt", NULL
32583 };
32584
32585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32586 if (obj0) {
32587 {
32588 arg1 = (int)(SWIG_As_int(obj0));
32589 if (SWIG_arg_fail(1)) SWIG_fail;
32590 }
32591 }
32592 {
32593 PyThreadState* __tstate = wxPyBeginAllowThreads();
32594 wxValidator::SetBellOnError(arg1);
32595
32596 wxPyEndAllowThreads(__tstate);
32597 if (PyErr_Occurred()) SWIG_fail;
32598 }
32599 Py_INCREF(Py_None); resultobj = Py_None;
32600 return resultobj;
32601 fail:
32602 return NULL;
32603 }
32604
32605
32606 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32607 PyObject *obj;
32608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32609 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32610 Py_INCREF(obj);
32611 return Py_BuildValue((char *)"");
32612 }
32613 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32614 PyObject *resultobj;
32615 wxPyValidator *result;
32616 char *kwnames[] = {
32617 NULL
32618 };
32619
32620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32621 {
32622 PyThreadState* __tstate = wxPyBeginAllowThreads();
32623 result = (wxPyValidator *)new wxPyValidator();
32624
32625 wxPyEndAllowThreads(__tstate);
32626 if (PyErr_Occurred()) SWIG_fail;
32627 }
32628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32629 return resultobj;
32630 fail:
32631 return NULL;
32632 }
32633
32634
32635 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32636 PyObject *resultobj;
32637 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32638 PyObject *arg2 = (PyObject *) 0 ;
32639 PyObject *arg3 = (PyObject *) 0 ;
32640 int arg4 = (int) true ;
32641 PyObject * obj0 = 0 ;
32642 PyObject * obj1 = 0 ;
32643 PyObject * obj2 = 0 ;
32644 PyObject * obj3 = 0 ;
32645 char *kwnames[] = {
32646 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32647 };
32648
32649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32651 if (SWIG_arg_fail(1)) SWIG_fail;
32652 arg2 = obj1;
32653 arg3 = obj2;
32654 if (obj3) {
32655 {
32656 arg4 = (int)(SWIG_As_int(obj3));
32657 if (SWIG_arg_fail(4)) SWIG_fail;
32658 }
32659 }
32660 {
32661 PyThreadState* __tstate = wxPyBeginAllowThreads();
32662 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32663
32664 wxPyEndAllowThreads(__tstate);
32665 if (PyErr_Occurred()) SWIG_fail;
32666 }
32667 Py_INCREF(Py_None); resultobj = Py_None;
32668 return resultobj;
32669 fail:
32670 return NULL;
32671 }
32672
32673
32674 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32675 PyObject *obj;
32676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32677 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32678 Py_INCREF(obj);
32679 return Py_BuildValue((char *)"");
32680 }
32681 static int _wrap_DefaultValidator_set(PyObject *) {
32682 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32683 return 1;
32684 }
32685
32686
32687 static PyObject *_wrap_DefaultValidator_get(void) {
32688 PyObject *pyobj;
32689
32690 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32691 return pyobj;
32692 }
32693
32694
32695 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32696 PyObject *resultobj;
32697 wxString const &arg1_defvalue = wxPyEmptyString ;
32698 wxString *arg1 = (wxString *) &arg1_defvalue ;
32699 long arg2 = (long) 0 ;
32700 wxMenu *result;
32701 bool temp1 = false ;
32702 PyObject * obj0 = 0 ;
32703 PyObject * obj1 = 0 ;
32704 char *kwnames[] = {
32705 (char *) "title",(char *) "style", NULL
32706 };
32707
32708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32709 if (obj0) {
32710 {
32711 arg1 = wxString_in_helper(obj0);
32712 if (arg1 == NULL) SWIG_fail;
32713 temp1 = true;
32714 }
32715 }
32716 if (obj1) {
32717 {
32718 arg2 = (long)(SWIG_As_long(obj1));
32719 if (SWIG_arg_fail(2)) SWIG_fail;
32720 }
32721 }
32722 {
32723 if (!wxPyCheckForApp()) SWIG_fail;
32724 PyThreadState* __tstate = wxPyBeginAllowThreads();
32725 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32726
32727 wxPyEndAllowThreads(__tstate);
32728 if (PyErr_Occurred()) SWIG_fail;
32729 }
32730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32731 {
32732 if (temp1)
32733 delete arg1;
32734 }
32735 return resultobj;
32736 fail:
32737 {
32738 if (temp1)
32739 delete arg1;
32740 }
32741 return NULL;
32742 }
32743
32744
32745 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32746 PyObject *resultobj;
32747 wxMenu *arg1 = (wxMenu *) 0 ;
32748 int arg2 ;
32749 wxString *arg3 = 0 ;
32750 wxString const &arg4_defvalue = wxPyEmptyString ;
32751 wxString *arg4 = (wxString *) &arg4_defvalue ;
32752 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32753 wxMenuItem *result;
32754 bool temp3 = false ;
32755 bool temp4 = false ;
32756 PyObject * obj0 = 0 ;
32757 PyObject * obj1 = 0 ;
32758 PyObject * obj2 = 0 ;
32759 PyObject * obj3 = 0 ;
32760 PyObject * obj4 = 0 ;
32761 char *kwnames[] = {
32762 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32763 };
32764
32765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32767 if (SWIG_arg_fail(1)) SWIG_fail;
32768 {
32769 arg2 = (int)(SWIG_As_int(obj1));
32770 if (SWIG_arg_fail(2)) SWIG_fail;
32771 }
32772 {
32773 arg3 = wxString_in_helper(obj2);
32774 if (arg3 == NULL) SWIG_fail;
32775 temp3 = true;
32776 }
32777 if (obj3) {
32778 {
32779 arg4 = wxString_in_helper(obj3);
32780 if (arg4 == NULL) SWIG_fail;
32781 temp4 = true;
32782 }
32783 }
32784 if (obj4) {
32785 {
32786 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32787 if (SWIG_arg_fail(5)) SWIG_fail;
32788 }
32789 }
32790 {
32791 PyThreadState* __tstate = wxPyBeginAllowThreads();
32792 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32793
32794 wxPyEndAllowThreads(__tstate);
32795 if (PyErr_Occurred()) SWIG_fail;
32796 }
32797 {
32798 resultobj = wxPyMake_wxObject(result, 0);
32799 }
32800 {
32801 if (temp3)
32802 delete arg3;
32803 }
32804 {
32805 if (temp4)
32806 delete arg4;
32807 }
32808 return resultobj;
32809 fail:
32810 {
32811 if (temp3)
32812 delete arg3;
32813 }
32814 {
32815 if (temp4)
32816 delete arg4;
32817 }
32818 return NULL;
32819 }
32820
32821
32822 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32823 PyObject *resultobj;
32824 wxMenu *arg1 = (wxMenu *) 0 ;
32825 wxMenuItem *result;
32826 PyObject * obj0 = 0 ;
32827 char *kwnames[] = {
32828 (char *) "self", NULL
32829 };
32830
32831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32833 if (SWIG_arg_fail(1)) SWIG_fail;
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 result = (wxMenuItem *)(arg1)->AppendSeparator();
32837
32838 wxPyEndAllowThreads(__tstate);
32839 if (PyErr_Occurred()) SWIG_fail;
32840 }
32841 {
32842 resultobj = wxPyMake_wxObject(result, 0);
32843 }
32844 return resultobj;
32845 fail:
32846 return NULL;
32847 }
32848
32849
32850 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32851 PyObject *resultobj;
32852 wxMenu *arg1 = (wxMenu *) 0 ;
32853 int arg2 ;
32854 wxString *arg3 = 0 ;
32855 wxString const &arg4_defvalue = wxPyEmptyString ;
32856 wxString *arg4 = (wxString *) &arg4_defvalue ;
32857 wxMenuItem *result;
32858 bool temp3 = false ;
32859 bool temp4 = false ;
32860 PyObject * obj0 = 0 ;
32861 PyObject * obj1 = 0 ;
32862 PyObject * obj2 = 0 ;
32863 PyObject * obj3 = 0 ;
32864 char *kwnames[] = {
32865 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32866 };
32867
32868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32870 if (SWIG_arg_fail(1)) SWIG_fail;
32871 {
32872 arg2 = (int)(SWIG_As_int(obj1));
32873 if (SWIG_arg_fail(2)) SWIG_fail;
32874 }
32875 {
32876 arg3 = wxString_in_helper(obj2);
32877 if (arg3 == NULL) SWIG_fail;
32878 temp3 = true;
32879 }
32880 if (obj3) {
32881 {
32882 arg4 = wxString_in_helper(obj3);
32883 if (arg4 == NULL) SWIG_fail;
32884 temp4 = true;
32885 }
32886 }
32887 {
32888 PyThreadState* __tstate = wxPyBeginAllowThreads();
32889 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32890
32891 wxPyEndAllowThreads(__tstate);
32892 if (PyErr_Occurred()) SWIG_fail;
32893 }
32894 {
32895 resultobj = wxPyMake_wxObject(result, 0);
32896 }
32897 {
32898 if (temp3)
32899 delete arg3;
32900 }
32901 {
32902 if (temp4)
32903 delete arg4;
32904 }
32905 return resultobj;
32906 fail:
32907 {
32908 if (temp3)
32909 delete arg3;
32910 }
32911 {
32912 if (temp4)
32913 delete arg4;
32914 }
32915 return NULL;
32916 }
32917
32918
32919 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32920 PyObject *resultobj;
32921 wxMenu *arg1 = (wxMenu *) 0 ;
32922 int arg2 ;
32923 wxString *arg3 = 0 ;
32924 wxString const &arg4_defvalue = wxPyEmptyString ;
32925 wxString *arg4 = (wxString *) &arg4_defvalue ;
32926 wxMenuItem *result;
32927 bool temp3 = false ;
32928 bool temp4 = false ;
32929 PyObject * obj0 = 0 ;
32930 PyObject * obj1 = 0 ;
32931 PyObject * obj2 = 0 ;
32932 PyObject * obj3 = 0 ;
32933 char *kwnames[] = {
32934 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32935 };
32936
32937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32939 if (SWIG_arg_fail(1)) SWIG_fail;
32940 {
32941 arg2 = (int)(SWIG_As_int(obj1));
32942 if (SWIG_arg_fail(2)) SWIG_fail;
32943 }
32944 {
32945 arg3 = wxString_in_helper(obj2);
32946 if (arg3 == NULL) SWIG_fail;
32947 temp3 = true;
32948 }
32949 if (obj3) {
32950 {
32951 arg4 = wxString_in_helper(obj3);
32952 if (arg4 == NULL) SWIG_fail;
32953 temp4 = true;
32954 }
32955 }
32956 {
32957 PyThreadState* __tstate = wxPyBeginAllowThreads();
32958 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32959
32960 wxPyEndAllowThreads(__tstate);
32961 if (PyErr_Occurred()) SWIG_fail;
32962 }
32963 {
32964 resultobj = wxPyMake_wxObject(result, 0);
32965 }
32966 {
32967 if (temp3)
32968 delete arg3;
32969 }
32970 {
32971 if (temp4)
32972 delete arg4;
32973 }
32974 return resultobj;
32975 fail:
32976 {
32977 if (temp3)
32978 delete arg3;
32979 }
32980 {
32981 if (temp4)
32982 delete arg4;
32983 }
32984 return NULL;
32985 }
32986
32987
32988 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32989 PyObject *resultobj;
32990 wxMenu *arg1 = (wxMenu *) 0 ;
32991 int arg2 ;
32992 wxString *arg3 = 0 ;
32993 wxMenu *arg4 = (wxMenu *) 0 ;
32994 wxString const &arg5_defvalue = wxPyEmptyString ;
32995 wxString *arg5 = (wxString *) &arg5_defvalue ;
32996 wxMenuItem *result;
32997 bool temp3 = false ;
32998 bool temp5 = false ;
32999 PyObject * obj0 = 0 ;
33000 PyObject * obj1 = 0 ;
33001 PyObject * obj2 = 0 ;
33002 PyObject * obj3 = 0 ;
33003 PyObject * obj4 = 0 ;
33004 char *kwnames[] = {
33005 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33006 };
33007
33008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33010 if (SWIG_arg_fail(1)) SWIG_fail;
33011 {
33012 arg2 = (int)(SWIG_As_int(obj1));
33013 if (SWIG_arg_fail(2)) SWIG_fail;
33014 }
33015 {
33016 arg3 = wxString_in_helper(obj2);
33017 if (arg3 == NULL) SWIG_fail;
33018 temp3 = true;
33019 }
33020 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33021 if (SWIG_arg_fail(4)) SWIG_fail;
33022 if (obj4) {
33023 {
33024 arg5 = wxString_in_helper(obj4);
33025 if (arg5 == NULL) SWIG_fail;
33026 temp5 = true;
33027 }
33028 }
33029 {
33030 PyThreadState* __tstate = wxPyBeginAllowThreads();
33031 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33032
33033 wxPyEndAllowThreads(__tstate);
33034 if (PyErr_Occurred()) SWIG_fail;
33035 }
33036 {
33037 resultobj = wxPyMake_wxObject(result, 0);
33038 }
33039 {
33040 if (temp3)
33041 delete arg3;
33042 }
33043 {
33044 if (temp5)
33045 delete arg5;
33046 }
33047 return resultobj;
33048 fail:
33049 {
33050 if (temp3)
33051 delete arg3;
33052 }
33053 {
33054 if (temp5)
33055 delete arg5;
33056 }
33057 return NULL;
33058 }
33059
33060
33061 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33062 PyObject *resultobj;
33063 wxMenu *arg1 = (wxMenu *) 0 ;
33064 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33065 wxMenuItem *result;
33066 PyObject * obj0 = 0 ;
33067 PyObject * obj1 = 0 ;
33068 char *kwnames[] = {
33069 (char *) "self",(char *) "item", NULL
33070 };
33071
33072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33074 if (SWIG_arg_fail(1)) SWIG_fail;
33075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33076 if (SWIG_arg_fail(2)) SWIG_fail;
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 result = (wxMenuItem *)(arg1)->Append(arg2);
33080
33081 wxPyEndAllowThreads(__tstate);
33082 if (PyErr_Occurred()) SWIG_fail;
33083 }
33084 {
33085 resultobj = wxPyMake_wxObject(result, 0);
33086 }
33087 return resultobj;
33088 fail:
33089 return NULL;
33090 }
33091
33092
33093 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33094 PyObject *resultobj;
33095 wxMenu *arg1 = (wxMenu *) 0 ;
33096 PyObject * obj0 = 0 ;
33097 char *kwnames[] = {
33098 (char *) "self", NULL
33099 };
33100
33101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33103 if (SWIG_arg_fail(1)) SWIG_fail;
33104 {
33105 PyThreadState* __tstate = wxPyBeginAllowThreads();
33106 (arg1)->Break();
33107
33108 wxPyEndAllowThreads(__tstate);
33109 if (PyErr_Occurred()) SWIG_fail;
33110 }
33111 Py_INCREF(Py_None); resultobj = Py_None;
33112 return resultobj;
33113 fail:
33114 return NULL;
33115 }
33116
33117
33118 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33119 PyObject *resultobj;
33120 wxMenu *arg1 = (wxMenu *) 0 ;
33121 size_t arg2 ;
33122 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33123 wxMenuItem *result;
33124 PyObject * obj0 = 0 ;
33125 PyObject * obj1 = 0 ;
33126 PyObject * obj2 = 0 ;
33127 char *kwnames[] = {
33128 (char *) "self",(char *) "pos",(char *) "item", NULL
33129 };
33130
33131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33133 if (SWIG_arg_fail(1)) SWIG_fail;
33134 {
33135 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33136 if (SWIG_arg_fail(2)) SWIG_fail;
33137 }
33138 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33139 if (SWIG_arg_fail(3)) SWIG_fail;
33140 {
33141 PyThreadState* __tstate = wxPyBeginAllowThreads();
33142 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33143
33144 wxPyEndAllowThreads(__tstate);
33145 if (PyErr_Occurred()) SWIG_fail;
33146 }
33147 {
33148 resultobj = wxPyMake_wxObject(result, 0);
33149 }
33150 return resultobj;
33151 fail:
33152 return NULL;
33153 }
33154
33155
33156 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33157 PyObject *resultobj;
33158 wxMenu *arg1 = (wxMenu *) 0 ;
33159 size_t arg2 ;
33160 int arg3 ;
33161 wxString *arg4 = 0 ;
33162 wxString const &arg5_defvalue = wxPyEmptyString ;
33163 wxString *arg5 = (wxString *) &arg5_defvalue ;
33164 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33165 wxMenuItem *result;
33166 bool temp4 = false ;
33167 bool temp5 = false ;
33168 PyObject * obj0 = 0 ;
33169 PyObject * obj1 = 0 ;
33170 PyObject * obj2 = 0 ;
33171 PyObject * obj3 = 0 ;
33172 PyObject * obj4 = 0 ;
33173 PyObject * obj5 = 0 ;
33174 char *kwnames[] = {
33175 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33176 };
33177
33178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33180 if (SWIG_arg_fail(1)) SWIG_fail;
33181 {
33182 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33183 if (SWIG_arg_fail(2)) SWIG_fail;
33184 }
33185 {
33186 arg3 = (int)(SWIG_As_int(obj2));
33187 if (SWIG_arg_fail(3)) SWIG_fail;
33188 }
33189 {
33190 arg4 = wxString_in_helper(obj3);
33191 if (arg4 == NULL) SWIG_fail;
33192 temp4 = true;
33193 }
33194 if (obj4) {
33195 {
33196 arg5 = wxString_in_helper(obj4);
33197 if (arg5 == NULL) SWIG_fail;
33198 temp5 = true;
33199 }
33200 }
33201 if (obj5) {
33202 {
33203 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33204 if (SWIG_arg_fail(6)) SWIG_fail;
33205 }
33206 }
33207 {
33208 PyThreadState* __tstate = wxPyBeginAllowThreads();
33209 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33210
33211 wxPyEndAllowThreads(__tstate);
33212 if (PyErr_Occurred()) SWIG_fail;
33213 }
33214 {
33215 resultobj = wxPyMake_wxObject(result, 0);
33216 }
33217 {
33218 if (temp4)
33219 delete arg4;
33220 }
33221 {
33222 if (temp5)
33223 delete arg5;
33224 }
33225 return resultobj;
33226 fail:
33227 {
33228 if (temp4)
33229 delete arg4;
33230 }
33231 {
33232 if (temp5)
33233 delete arg5;
33234 }
33235 return NULL;
33236 }
33237
33238
33239 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33240 PyObject *resultobj;
33241 wxMenu *arg1 = (wxMenu *) 0 ;
33242 size_t arg2 ;
33243 wxMenuItem *result;
33244 PyObject * obj0 = 0 ;
33245 PyObject * obj1 = 0 ;
33246 char *kwnames[] = {
33247 (char *) "self",(char *) "pos", NULL
33248 };
33249
33250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33252 if (SWIG_arg_fail(1)) SWIG_fail;
33253 {
33254 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33255 if (SWIG_arg_fail(2)) SWIG_fail;
33256 }
33257 {
33258 PyThreadState* __tstate = wxPyBeginAllowThreads();
33259 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33260
33261 wxPyEndAllowThreads(__tstate);
33262 if (PyErr_Occurred()) SWIG_fail;
33263 }
33264 {
33265 resultobj = wxPyMake_wxObject(result, 0);
33266 }
33267 return resultobj;
33268 fail:
33269 return NULL;
33270 }
33271
33272
33273 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33274 PyObject *resultobj;
33275 wxMenu *arg1 = (wxMenu *) 0 ;
33276 size_t arg2 ;
33277 int arg3 ;
33278 wxString *arg4 = 0 ;
33279 wxString const &arg5_defvalue = wxPyEmptyString ;
33280 wxString *arg5 = (wxString *) &arg5_defvalue ;
33281 wxMenuItem *result;
33282 bool temp4 = false ;
33283 bool temp5 = false ;
33284 PyObject * obj0 = 0 ;
33285 PyObject * obj1 = 0 ;
33286 PyObject * obj2 = 0 ;
33287 PyObject * obj3 = 0 ;
33288 PyObject * obj4 = 0 ;
33289 char *kwnames[] = {
33290 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33291 };
33292
33293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33295 if (SWIG_arg_fail(1)) SWIG_fail;
33296 {
33297 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33298 if (SWIG_arg_fail(2)) SWIG_fail;
33299 }
33300 {
33301 arg3 = (int)(SWIG_As_int(obj2));
33302 if (SWIG_arg_fail(3)) SWIG_fail;
33303 }
33304 {
33305 arg4 = wxString_in_helper(obj3);
33306 if (arg4 == NULL) SWIG_fail;
33307 temp4 = true;
33308 }
33309 if (obj4) {
33310 {
33311 arg5 = wxString_in_helper(obj4);
33312 if (arg5 == NULL) SWIG_fail;
33313 temp5 = true;
33314 }
33315 }
33316 {
33317 PyThreadState* __tstate = wxPyBeginAllowThreads();
33318 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33319
33320 wxPyEndAllowThreads(__tstate);
33321 if (PyErr_Occurred()) SWIG_fail;
33322 }
33323 {
33324 resultobj = wxPyMake_wxObject(result, 0);
33325 }
33326 {
33327 if (temp4)
33328 delete arg4;
33329 }
33330 {
33331 if (temp5)
33332 delete arg5;
33333 }
33334 return resultobj;
33335 fail:
33336 {
33337 if (temp4)
33338 delete arg4;
33339 }
33340 {
33341 if (temp5)
33342 delete arg5;
33343 }
33344 return NULL;
33345 }
33346
33347
33348 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33349 PyObject *resultobj;
33350 wxMenu *arg1 = (wxMenu *) 0 ;
33351 size_t arg2 ;
33352 int arg3 ;
33353 wxString *arg4 = 0 ;
33354 wxString const &arg5_defvalue = wxPyEmptyString ;
33355 wxString *arg5 = (wxString *) &arg5_defvalue ;
33356 wxMenuItem *result;
33357 bool temp4 = false ;
33358 bool temp5 = false ;
33359 PyObject * obj0 = 0 ;
33360 PyObject * obj1 = 0 ;
33361 PyObject * obj2 = 0 ;
33362 PyObject * obj3 = 0 ;
33363 PyObject * obj4 = 0 ;
33364 char *kwnames[] = {
33365 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33366 };
33367
33368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33370 if (SWIG_arg_fail(1)) SWIG_fail;
33371 {
33372 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33373 if (SWIG_arg_fail(2)) SWIG_fail;
33374 }
33375 {
33376 arg3 = (int)(SWIG_As_int(obj2));
33377 if (SWIG_arg_fail(3)) SWIG_fail;
33378 }
33379 {
33380 arg4 = wxString_in_helper(obj3);
33381 if (arg4 == NULL) SWIG_fail;
33382 temp4 = true;
33383 }
33384 if (obj4) {
33385 {
33386 arg5 = wxString_in_helper(obj4);
33387 if (arg5 == NULL) SWIG_fail;
33388 temp5 = true;
33389 }
33390 }
33391 {
33392 PyThreadState* __tstate = wxPyBeginAllowThreads();
33393 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33394
33395 wxPyEndAllowThreads(__tstate);
33396 if (PyErr_Occurred()) SWIG_fail;
33397 }
33398 {
33399 resultobj = wxPyMake_wxObject(result, 0);
33400 }
33401 {
33402 if (temp4)
33403 delete arg4;
33404 }
33405 {
33406 if (temp5)
33407 delete arg5;
33408 }
33409 return resultobj;
33410 fail:
33411 {
33412 if (temp4)
33413 delete arg4;
33414 }
33415 {
33416 if (temp5)
33417 delete arg5;
33418 }
33419 return NULL;
33420 }
33421
33422
33423 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33424 PyObject *resultobj;
33425 wxMenu *arg1 = (wxMenu *) 0 ;
33426 size_t arg2 ;
33427 int arg3 ;
33428 wxString *arg4 = 0 ;
33429 wxMenu *arg5 = (wxMenu *) 0 ;
33430 wxString const &arg6_defvalue = wxPyEmptyString ;
33431 wxString *arg6 = (wxString *) &arg6_defvalue ;
33432 wxMenuItem *result;
33433 bool temp4 = false ;
33434 bool temp6 = false ;
33435 PyObject * obj0 = 0 ;
33436 PyObject * obj1 = 0 ;
33437 PyObject * obj2 = 0 ;
33438 PyObject * obj3 = 0 ;
33439 PyObject * obj4 = 0 ;
33440 PyObject * obj5 = 0 ;
33441 char *kwnames[] = {
33442 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33443 };
33444
33445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33447 if (SWIG_arg_fail(1)) SWIG_fail;
33448 {
33449 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33450 if (SWIG_arg_fail(2)) SWIG_fail;
33451 }
33452 {
33453 arg3 = (int)(SWIG_As_int(obj2));
33454 if (SWIG_arg_fail(3)) SWIG_fail;
33455 }
33456 {
33457 arg4 = wxString_in_helper(obj3);
33458 if (arg4 == NULL) SWIG_fail;
33459 temp4 = true;
33460 }
33461 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33462 if (SWIG_arg_fail(5)) SWIG_fail;
33463 if (obj5) {
33464 {
33465 arg6 = wxString_in_helper(obj5);
33466 if (arg6 == NULL) SWIG_fail;
33467 temp6 = true;
33468 }
33469 }
33470 {
33471 PyThreadState* __tstate = wxPyBeginAllowThreads();
33472 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33473
33474 wxPyEndAllowThreads(__tstate);
33475 if (PyErr_Occurred()) SWIG_fail;
33476 }
33477 {
33478 resultobj = wxPyMake_wxObject(result, 0);
33479 }
33480 {
33481 if (temp4)
33482 delete arg4;
33483 }
33484 {
33485 if (temp6)
33486 delete arg6;
33487 }
33488 return resultobj;
33489 fail:
33490 {
33491 if (temp4)
33492 delete arg4;
33493 }
33494 {
33495 if (temp6)
33496 delete arg6;
33497 }
33498 return NULL;
33499 }
33500
33501
33502 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33503 PyObject *resultobj;
33504 wxMenu *arg1 = (wxMenu *) 0 ;
33505 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33506 wxMenuItem *result;
33507 PyObject * obj0 = 0 ;
33508 PyObject * obj1 = 0 ;
33509 char *kwnames[] = {
33510 (char *) "self",(char *) "item", NULL
33511 };
33512
33513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33515 if (SWIG_arg_fail(1)) SWIG_fail;
33516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33517 if (SWIG_arg_fail(2)) SWIG_fail;
33518 {
33519 PyThreadState* __tstate = wxPyBeginAllowThreads();
33520 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33521
33522 wxPyEndAllowThreads(__tstate);
33523 if (PyErr_Occurred()) SWIG_fail;
33524 }
33525 {
33526 resultobj = wxPyMake_wxObject(result, 0);
33527 }
33528 return resultobj;
33529 fail:
33530 return NULL;
33531 }
33532
33533
33534 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33535 PyObject *resultobj;
33536 wxMenu *arg1 = (wxMenu *) 0 ;
33537 int arg2 ;
33538 wxString *arg3 = 0 ;
33539 wxString const &arg4_defvalue = wxPyEmptyString ;
33540 wxString *arg4 = (wxString *) &arg4_defvalue ;
33541 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33542 wxMenuItem *result;
33543 bool temp3 = false ;
33544 bool temp4 = false ;
33545 PyObject * obj0 = 0 ;
33546 PyObject * obj1 = 0 ;
33547 PyObject * obj2 = 0 ;
33548 PyObject * obj3 = 0 ;
33549 PyObject * obj4 = 0 ;
33550 char *kwnames[] = {
33551 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33552 };
33553
33554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33556 if (SWIG_arg_fail(1)) SWIG_fail;
33557 {
33558 arg2 = (int)(SWIG_As_int(obj1));
33559 if (SWIG_arg_fail(2)) SWIG_fail;
33560 }
33561 {
33562 arg3 = wxString_in_helper(obj2);
33563 if (arg3 == NULL) SWIG_fail;
33564 temp3 = true;
33565 }
33566 if (obj3) {
33567 {
33568 arg4 = wxString_in_helper(obj3);
33569 if (arg4 == NULL) SWIG_fail;
33570 temp4 = true;
33571 }
33572 }
33573 if (obj4) {
33574 {
33575 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33576 if (SWIG_arg_fail(5)) SWIG_fail;
33577 }
33578 }
33579 {
33580 PyThreadState* __tstate = wxPyBeginAllowThreads();
33581 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33582
33583 wxPyEndAllowThreads(__tstate);
33584 if (PyErr_Occurred()) SWIG_fail;
33585 }
33586 {
33587 resultobj = wxPyMake_wxObject(result, 0);
33588 }
33589 {
33590 if (temp3)
33591 delete arg3;
33592 }
33593 {
33594 if (temp4)
33595 delete arg4;
33596 }
33597 return resultobj;
33598 fail:
33599 {
33600 if (temp3)
33601 delete arg3;
33602 }
33603 {
33604 if (temp4)
33605 delete arg4;
33606 }
33607 return NULL;
33608 }
33609
33610
33611 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33612 PyObject *resultobj;
33613 wxMenu *arg1 = (wxMenu *) 0 ;
33614 wxMenuItem *result;
33615 PyObject * obj0 = 0 ;
33616 char *kwnames[] = {
33617 (char *) "self", NULL
33618 };
33619
33620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33622 if (SWIG_arg_fail(1)) SWIG_fail;
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 result = (wxMenuItem *)(arg1)->PrependSeparator();
33626
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 {
33631 resultobj = wxPyMake_wxObject(result, 0);
33632 }
33633 return resultobj;
33634 fail:
33635 return NULL;
33636 }
33637
33638
33639 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33640 PyObject *resultobj;
33641 wxMenu *arg1 = (wxMenu *) 0 ;
33642 int arg2 ;
33643 wxString *arg3 = 0 ;
33644 wxString const &arg4_defvalue = wxPyEmptyString ;
33645 wxString *arg4 = (wxString *) &arg4_defvalue ;
33646 wxMenuItem *result;
33647 bool temp3 = false ;
33648 bool temp4 = false ;
33649 PyObject * obj0 = 0 ;
33650 PyObject * obj1 = 0 ;
33651 PyObject * obj2 = 0 ;
33652 PyObject * obj3 = 0 ;
33653 char *kwnames[] = {
33654 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33655 };
33656
33657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33659 if (SWIG_arg_fail(1)) SWIG_fail;
33660 {
33661 arg2 = (int)(SWIG_As_int(obj1));
33662 if (SWIG_arg_fail(2)) SWIG_fail;
33663 }
33664 {
33665 arg3 = wxString_in_helper(obj2);
33666 if (arg3 == NULL) SWIG_fail;
33667 temp3 = true;
33668 }
33669 if (obj3) {
33670 {
33671 arg4 = wxString_in_helper(obj3);
33672 if (arg4 == NULL) SWIG_fail;
33673 temp4 = true;
33674 }
33675 }
33676 {
33677 PyThreadState* __tstate = wxPyBeginAllowThreads();
33678 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33679
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 {
33684 resultobj = wxPyMake_wxObject(result, 0);
33685 }
33686 {
33687 if (temp3)
33688 delete arg3;
33689 }
33690 {
33691 if (temp4)
33692 delete arg4;
33693 }
33694 return resultobj;
33695 fail:
33696 {
33697 if (temp3)
33698 delete arg3;
33699 }
33700 {
33701 if (temp4)
33702 delete arg4;
33703 }
33704 return NULL;
33705 }
33706
33707
33708 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33709 PyObject *resultobj;
33710 wxMenu *arg1 = (wxMenu *) 0 ;
33711 int arg2 ;
33712 wxString *arg3 = 0 ;
33713 wxString const &arg4_defvalue = wxPyEmptyString ;
33714 wxString *arg4 = (wxString *) &arg4_defvalue ;
33715 wxMenuItem *result;
33716 bool temp3 = false ;
33717 bool temp4 = false ;
33718 PyObject * obj0 = 0 ;
33719 PyObject * obj1 = 0 ;
33720 PyObject * obj2 = 0 ;
33721 PyObject * obj3 = 0 ;
33722 char *kwnames[] = {
33723 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33724 };
33725
33726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33728 if (SWIG_arg_fail(1)) SWIG_fail;
33729 {
33730 arg2 = (int)(SWIG_As_int(obj1));
33731 if (SWIG_arg_fail(2)) SWIG_fail;
33732 }
33733 {
33734 arg3 = wxString_in_helper(obj2);
33735 if (arg3 == NULL) SWIG_fail;
33736 temp3 = true;
33737 }
33738 if (obj3) {
33739 {
33740 arg4 = wxString_in_helper(obj3);
33741 if (arg4 == NULL) SWIG_fail;
33742 temp4 = true;
33743 }
33744 }
33745 {
33746 PyThreadState* __tstate = wxPyBeginAllowThreads();
33747 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33748
33749 wxPyEndAllowThreads(__tstate);
33750 if (PyErr_Occurred()) SWIG_fail;
33751 }
33752 {
33753 resultobj = wxPyMake_wxObject(result, 0);
33754 }
33755 {
33756 if (temp3)
33757 delete arg3;
33758 }
33759 {
33760 if (temp4)
33761 delete arg4;
33762 }
33763 return resultobj;
33764 fail:
33765 {
33766 if (temp3)
33767 delete arg3;
33768 }
33769 {
33770 if (temp4)
33771 delete arg4;
33772 }
33773 return NULL;
33774 }
33775
33776
33777 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33778 PyObject *resultobj;
33779 wxMenu *arg1 = (wxMenu *) 0 ;
33780 int arg2 ;
33781 wxString *arg3 = 0 ;
33782 wxMenu *arg4 = (wxMenu *) 0 ;
33783 wxString const &arg5_defvalue = wxPyEmptyString ;
33784 wxString *arg5 = (wxString *) &arg5_defvalue ;
33785 wxMenuItem *result;
33786 bool temp3 = false ;
33787 bool temp5 = false ;
33788 PyObject * obj0 = 0 ;
33789 PyObject * obj1 = 0 ;
33790 PyObject * obj2 = 0 ;
33791 PyObject * obj3 = 0 ;
33792 PyObject * obj4 = 0 ;
33793 char *kwnames[] = {
33794 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33795 };
33796
33797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33799 if (SWIG_arg_fail(1)) SWIG_fail;
33800 {
33801 arg2 = (int)(SWIG_As_int(obj1));
33802 if (SWIG_arg_fail(2)) SWIG_fail;
33803 }
33804 {
33805 arg3 = wxString_in_helper(obj2);
33806 if (arg3 == NULL) SWIG_fail;
33807 temp3 = true;
33808 }
33809 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33810 if (SWIG_arg_fail(4)) SWIG_fail;
33811 if (obj4) {
33812 {
33813 arg5 = wxString_in_helper(obj4);
33814 if (arg5 == NULL) SWIG_fail;
33815 temp5 = true;
33816 }
33817 }
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33821
33822 wxPyEndAllowThreads(__tstate);
33823 if (PyErr_Occurred()) SWIG_fail;
33824 }
33825 {
33826 resultobj = wxPyMake_wxObject(result, 0);
33827 }
33828 {
33829 if (temp3)
33830 delete arg3;
33831 }
33832 {
33833 if (temp5)
33834 delete arg5;
33835 }
33836 return resultobj;
33837 fail:
33838 {
33839 if (temp3)
33840 delete arg3;
33841 }
33842 {
33843 if (temp5)
33844 delete arg5;
33845 }
33846 return NULL;
33847 }
33848
33849
33850 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33851 PyObject *resultobj;
33852 wxMenu *arg1 = (wxMenu *) 0 ;
33853 int arg2 ;
33854 wxMenuItem *result;
33855 PyObject * obj0 = 0 ;
33856 PyObject * obj1 = 0 ;
33857 char *kwnames[] = {
33858 (char *) "self",(char *) "id", NULL
33859 };
33860
33861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33863 if (SWIG_arg_fail(1)) SWIG_fail;
33864 {
33865 arg2 = (int)(SWIG_As_int(obj1));
33866 if (SWIG_arg_fail(2)) SWIG_fail;
33867 }
33868 {
33869 PyThreadState* __tstate = wxPyBeginAllowThreads();
33870 result = (wxMenuItem *)(arg1)->Remove(arg2);
33871
33872 wxPyEndAllowThreads(__tstate);
33873 if (PyErr_Occurred()) SWIG_fail;
33874 }
33875 {
33876 resultobj = wxPyMake_wxObject(result, 0);
33877 }
33878 return resultobj;
33879 fail:
33880 return NULL;
33881 }
33882
33883
33884 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33885 PyObject *resultobj;
33886 wxMenu *arg1 = (wxMenu *) 0 ;
33887 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33888 wxMenuItem *result;
33889 PyObject * obj0 = 0 ;
33890 PyObject * obj1 = 0 ;
33891 char *kwnames[] = {
33892 (char *) "self",(char *) "item", NULL
33893 };
33894
33895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33897 if (SWIG_arg_fail(1)) SWIG_fail;
33898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33899 if (SWIG_arg_fail(2)) SWIG_fail;
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 result = (wxMenuItem *)(arg1)->Remove(arg2);
33903
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 {
33908 resultobj = wxPyMake_wxObject(result, 0);
33909 }
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj;
33918 wxMenu *arg1 = (wxMenu *) 0 ;
33919 int arg2 ;
33920 bool result;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 char *kwnames[] = {
33924 (char *) "self",(char *) "id", NULL
33925 };
33926
33927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33929 if (SWIG_arg_fail(1)) SWIG_fail;
33930 {
33931 arg2 = (int)(SWIG_As_int(obj1));
33932 if (SWIG_arg_fail(2)) SWIG_fail;
33933 }
33934 {
33935 PyThreadState* __tstate = wxPyBeginAllowThreads();
33936 result = (bool)(arg1)->Delete(arg2);
33937
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 {
33942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33943 }
33944 return resultobj;
33945 fail:
33946 return NULL;
33947 }
33948
33949
33950 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33951 PyObject *resultobj;
33952 wxMenu *arg1 = (wxMenu *) 0 ;
33953 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33954 bool result;
33955 PyObject * obj0 = 0 ;
33956 PyObject * obj1 = 0 ;
33957 char *kwnames[] = {
33958 (char *) "self",(char *) "item", NULL
33959 };
33960
33961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33963 if (SWIG_arg_fail(1)) SWIG_fail;
33964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33965 if (SWIG_arg_fail(2)) SWIG_fail;
33966 {
33967 PyThreadState* __tstate = wxPyBeginAllowThreads();
33968 result = (bool)(arg1)->Delete(arg2);
33969
33970 wxPyEndAllowThreads(__tstate);
33971 if (PyErr_Occurred()) SWIG_fail;
33972 }
33973 {
33974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33975 }
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33983 PyObject *resultobj;
33984 wxMenu *arg1 = (wxMenu *) 0 ;
33985 PyObject * obj0 = 0 ;
33986 char *kwnames[] = {
33987 (char *) "self", NULL
33988 };
33989
33990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33992 if (SWIG_arg_fail(1)) SWIG_fail;
33993 {
33994 PyThreadState* __tstate = wxPyBeginAllowThreads();
33995 wxMenu_Destroy(arg1);
33996
33997 wxPyEndAllowThreads(__tstate);
33998 if (PyErr_Occurred()) SWIG_fail;
33999 }
34000 Py_INCREF(Py_None); resultobj = Py_None;
34001 return resultobj;
34002 fail:
34003 return NULL;
34004 }
34005
34006
34007 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34008 PyObject *resultobj;
34009 wxMenu *arg1 = (wxMenu *) 0 ;
34010 int arg2 ;
34011 bool result;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 char *kwnames[] = {
34015 (char *) "self",(char *) "id", NULL
34016 };
34017
34018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34020 if (SWIG_arg_fail(1)) SWIG_fail;
34021 {
34022 arg2 = (int)(SWIG_As_int(obj1));
34023 if (SWIG_arg_fail(2)) SWIG_fail;
34024 }
34025 {
34026 PyThreadState* __tstate = wxPyBeginAllowThreads();
34027 result = (bool)(arg1)->Destroy(arg2);
34028
34029 wxPyEndAllowThreads(__tstate);
34030 if (PyErr_Occurred()) SWIG_fail;
34031 }
34032 {
34033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34034 }
34035 return resultobj;
34036 fail:
34037 return NULL;
34038 }
34039
34040
34041 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34042 PyObject *resultobj;
34043 wxMenu *arg1 = (wxMenu *) 0 ;
34044 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34045 bool result;
34046 PyObject * obj0 = 0 ;
34047 PyObject * obj1 = 0 ;
34048 char *kwnames[] = {
34049 (char *) "self",(char *) "item", NULL
34050 };
34051
34052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34054 if (SWIG_arg_fail(1)) SWIG_fail;
34055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34056 if (SWIG_arg_fail(2)) SWIG_fail;
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (bool)(arg1)->Destroy(arg2);
34060
34061 wxPyEndAllowThreads(__tstate);
34062 if (PyErr_Occurred()) SWIG_fail;
34063 }
34064 {
34065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34066 }
34067 return resultobj;
34068 fail:
34069 return NULL;
34070 }
34071
34072
34073 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34074 PyObject *resultobj;
34075 wxMenu *arg1 = (wxMenu *) 0 ;
34076 size_t result;
34077 PyObject * obj0 = 0 ;
34078 char *kwnames[] = {
34079 (char *) "self", NULL
34080 };
34081
34082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34084 if (SWIG_arg_fail(1)) SWIG_fail;
34085 {
34086 PyThreadState* __tstate = wxPyBeginAllowThreads();
34087 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34088
34089 wxPyEndAllowThreads(__tstate);
34090 if (PyErr_Occurred()) SWIG_fail;
34091 }
34092 {
34093 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34094 }
34095 return resultobj;
34096 fail:
34097 return NULL;
34098 }
34099
34100
34101 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34102 PyObject *resultobj;
34103 wxMenu *arg1 = (wxMenu *) 0 ;
34104 PyObject *result;
34105 PyObject * obj0 = 0 ;
34106 char *kwnames[] = {
34107 (char *) "self", NULL
34108 };
34109
34110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34112 if (SWIG_arg_fail(1)) SWIG_fail;
34113 {
34114 PyThreadState* __tstate = wxPyBeginAllowThreads();
34115 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34116
34117 wxPyEndAllowThreads(__tstate);
34118 if (PyErr_Occurred()) SWIG_fail;
34119 }
34120 resultobj = result;
34121 return resultobj;
34122 fail:
34123 return NULL;
34124 }
34125
34126
34127 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34128 PyObject *resultobj;
34129 wxMenu *arg1 = (wxMenu *) 0 ;
34130 wxString *arg2 = 0 ;
34131 int result;
34132 bool temp2 = false ;
34133 PyObject * obj0 = 0 ;
34134 PyObject * obj1 = 0 ;
34135 char *kwnames[] = {
34136 (char *) "self",(char *) "item", NULL
34137 };
34138
34139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34141 if (SWIG_arg_fail(1)) SWIG_fail;
34142 {
34143 arg2 = wxString_in_helper(obj1);
34144 if (arg2 == NULL) SWIG_fail;
34145 temp2 = true;
34146 }
34147 {
34148 PyThreadState* __tstate = wxPyBeginAllowThreads();
34149 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34150
34151 wxPyEndAllowThreads(__tstate);
34152 if (PyErr_Occurred()) SWIG_fail;
34153 }
34154 {
34155 resultobj = SWIG_From_int((int)(result));
34156 }
34157 {
34158 if (temp2)
34159 delete arg2;
34160 }
34161 return resultobj;
34162 fail:
34163 {
34164 if (temp2)
34165 delete arg2;
34166 }
34167 return NULL;
34168 }
34169
34170
34171 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34172 PyObject *resultobj;
34173 wxMenu *arg1 = (wxMenu *) 0 ;
34174 int arg2 ;
34175 wxMenuItem *result;
34176 PyObject * obj0 = 0 ;
34177 PyObject * obj1 = 0 ;
34178 char *kwnames[] = {
34179 (char *) "self",(char *) "id", NULL
34180 };
34181
34182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34184 if (SWIG_arg_fail(1)) SWIG_fail;
34185 {
34186 arg2 = (int)(SWIG_As_int(obj1));
34187 if (SWIG_arg_fail(2)) SWIG_fail;
34188 }
34189 {
34190 PyThreadState* __tstate = wxPyBeginAllowThreads();
34191 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34192
34193 wxPyEndAllowThreads(__tstate);
34194 if (PyErr_Occurred()) SWIG_fail;
34195 }
34196 {
34197 resultobj = wxPyMake_wxObject(result, 0);
34198 }
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34206 PyObject *resultobj;
34207 wxMenu *arg1 = (wxMenu *) 0 ;
34208 size_t arg2 ;
34209 wxMenuItem *result;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 char *kwnames[] = {
34213 (char *) "self",(char *) "position", NULL
34214 };
34215
34216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34218 if (SWIG_arg_fail(1)) SWIG_fail;
34219 {
34220 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34221 if (SWIG_arg_fail(2)) SWIG_fail;
34222 }
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34226
34227 wxPyEndAllowThreads(__tstate);
34228 if (PyErr_Occurred()) SWIG_fail;
34229 }
34230 {
34231 resultobj = wxPyMake_wxObject(result, 0);
34232 }
34233 return resultobj;
34234 fail:
34235 return NULL;
34236 }
34237
34238
34239 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34240 PyObject *resultobj;
34241 wxMenu *arg1 = (wxMenu *) 0 ;
34242 int arg2 ;
34243 bool arg3 ;
34244 PyObject * obj0 = 0 ;
34245 PyObject * obj1 = 0 ;
34246 PyObject * obj2 = 0 ;
34247 char *kwnames[] = {
34248 (char *) "self",(char *) "id",(char *) "enable", NULL
34249 };
34250
34251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34253 if (SWIG_arg_fail(1)) SWIG_fail;
34254 {
34255 arg2 = (int)(SWIG_As_int(obj1));
34256 if (SWIG_arg_fail(2)) SWIG_fail;
34257 }
34258 {
34259 arg3 = (bool)(SWIG_As_bool(obj2));
34260 if (SWIG_arg_fail(3)) SWIG_fail;
34261 }
34262 {
34263 PyThreadState* __tstate = wxPyBeginAllowThreads();
34264 (arg1)->Enable(arg2,arg3);
34265
34266 wxPyEndAllowThreads(__tstate);
34267 if (PyErr_Occurred()) SWIG_fail;
34268 }
34269 Py_INCREF(Py_None); resultobj = Py_None;
34270 return resultobj;
34271 fail:
34272 return NULL;
34273 }
34274
34275
34276 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34277 PyObject *resultobj;
34278 wxMenu *arg1 = (wxMenu *) 0 ;
34279 int arg2 ;
34280 bool result;
34281 PyObject * obj0 = 0 ;
34282 PyObject * obj1 = 0 ;
34283 char *kwnames[] = {
34284 (char *) "self",(char *) "id", NULL
34285 };
34286
34287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34289 if (SWIG_arg_fail(1)) SWIG_fail;
34290 {
34291 arg2 = (int)(SWIG_As_int(obj1));
34292 if (SWIG_arg_fail(2)) SWIG_fail;
34293 }
34294 {
34295 PyThreadState* __tstate = wxPyBeginAllowThreads();
34296 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34297
34298 wxPyEndAllowThreads(__tstate);
34299 if (PyErr_Occurred()) SWIG_fail;
34300 }
34301 {
34302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34303 }
34304 return resultobj;
34305 fail:
34306 return NULL;
34307 }
34308
34309
34310 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34311 PyObject *resultobj;
34312 wxMenu *arg1 = (wxMenu *) 0 ;
34313 int arg2 ;
34314 bool arg3 ;
34315 PyObject * obj0 = 0 ;
34316 PyObject * obj1 = 0 ;
34317 PyObject * obj2 = 0 ;
34318 char *kwnames[] = {
34319 (char *) "self",(char *) "id",(char *) "check", NULL
34320 };
34321
34322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34324 if (SWIG_arg_fail(1)) SWIG_fail;
34325 {
34326 arg2 = (int)(SWIG_As_int(obj1));
34327 if (SWIG_arg_fail(2)) SWIG_fail;
34328 }
34329 {
34330 arg3 = (bool)(SWIG_As_bool(obj2));
34331 if (SWIG_arg_fail(3)) SWIG_fail;
34332 }
34333 {
34334 PyThreadState* __tstate = wxPyBeginAllowThreads();
34335 (arg1)->Check(arg2,arg3);
34336
34337 wxPyEndAllowThreads(__tstate);
34338 if (PyErr_Occurred()) SWIG_fail;
34339 }
34340 Py_INCREF(Py_None); resultobj = Py_None;
34341 return resultobj;
34342 fail:
34343 return NULL;
34344 }
34345
34346
34347 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34348 PyObject *resultobj;
34349 wxMenu *arg1 = (wxMenu *) 0 ;
34350 int arg2 ;
34351 bool result;
34352 PyObject * obj0 = 0 ;
34353 PyObject * obj1 = 0 ;
34354 char *kwnames[] = {
34355 (char *) "self",(char *) "id", NULL
34356 };
34357
34358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34360 if (SWIG_arg_fail(1)) SWIG_fail;
34361 {
34362 arg2 = (int)(SWIG_As_int(obj1));
34363 if (SWIG_arg_fail(2)) SWIG_fail;
34364 }
34365 {
34366 PyThreadState* __tstate = wxPyBeginAllowThreads();
34367 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34368
34369 wxPyEndAllowThreads(__tstate);
34370 if (PyErr_Occurred()) SWIG_fail;
34371 }
34372 {
34373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34374 }
34375 return resultobj;
34376 fail:
34377 return NULL;
34378 }
34379
34380
34381 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34382 PyObject *resultobj;
34383 wxMenu *arg1 = (wxMenu *) 0 ;
34384 int arg2 ;
34385 wxString *arg3 = 0 ;
34386 bool temp3 = false ;
34387 PyObject * obj0 = 0 ;
34388 PyObject * obj1 = 0 ;
34389 PyObject * obj2 = 0 ;
34390 char *kwnames[] = {
34391 (char *) "self",(char *) "id",(char *) "label", NULL
34392 };
34393
34394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34396 if (SWIG_arg_fail(1)) SWIG_fail;
34397 {
34398 arg2 = (int)(SWIG_As_int(obj1));
34399 if (SWIG_arg_fail(2)) SWIG_fail;
34400 }
34401 {
34402 arg3 = wxString_in_helper(obj2);
34403 if (arg3 == NULL) SWIG_fail;
34404 temp3 = true;
34405 }
34406 {
34407 PyThreadState* __tstate = wxPyBeginAllowThreads();
34408 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34409
34410 wxPyEndAllowThreads(__tstate);
34411 if (PyErr_Occurred()) SWIG_fail;
34412 }
34413 Py_INCREF(Py_None); resultobj = Py_None;
34414 {
34415 if (temp3)
34416 delete arg3;
34417 }
34418 return resultobj;
34419 fail:
34420 {
34421 if (temp3)
34422 delete arg3;
34423 }
34424 return NULL;
34425 }
34426
34427
34428 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34429 PyObject *resultobj;
34430 wxMenu *arg1 = (wxMenu *) 0 ;
34431 int arg2 ;
34432 wxString result;
34433 PyObject * obj0 = 0 ;
34434 PyObject * obj1 = 0 ;
34435 char *kwnames[] = {
34436 (char *) "self",(char *) "id", NULL
34437 };
34438
34439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34441 if (SWIG_arg_fail(1)) SWIG_fail;
34442 {
34443 arg2 = (int)(SWIG_As_int(obj1));
34444 if (SWIG_arg_fail(2)) SWIG_fail;
34445 }
34446 {
34447 PyThreadState* __tstate = wxPyBeginAllowThreads();
34448 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34449
34450 wxPyEndAllowThreads(__tstate);
34451 if (PyErr_Occurred()) SWIG_fail;
34452 }
34453 {
34454 #if wxUSE_UNICODE
34455 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34456 #else
34457 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34458 #endif
34459 }
34460 return resultobj;
34461 fail:
34462 return NULL;
34463 }
34464
34465
34466 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34467 PyObject *resultobj;
34468 wxMenu *arg1 = (wxMenu *) 0 ;
34469 int arg2 ;
34470 wxString *arg3 = 0 ;
34471 bool temp3 = false ;
34472 PyObject * obj0 = 0 ;
34473 PyObject * obj1 = 0 ;
34474 PyObject * obj2 = 0 ;
34475 char *kwnames[] = {
34476 (char *) "self",(char *) "id",(char *) "helpString", NULL
34477 };
34478
34479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34481 if (SWIG_arg_fail(1)) SWIG_fail;
34482 {
34483 arg2 = (int)(SWIG_As_int(obj1));
34484 if (SWIG_arg_fail(2)) SWIG_fail;
34485 }
34486 {
34487 arg3 = wxString_in_helper(obj2);
34488 if (arg3 == NULL) SWIG_fail;
34489 temp3 = true;
34490 }
34491 {
34492 PyThreadState* __tstate = wxPyBeginAllowThreads();
34493 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34494
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 Py_INCREF(Py_None); resultobj = Py_None;
34499 {
34500 if (temp3)
34501 delete arg3;
34502 }
34503 return resultobj;
34504 fail:
34505 {
34506 if (temp3)
34507 delete arg3;
34508 }
34509 return NULL;
34510 }
34511
34512
34513 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34514 PyObject *resultobj;
34515 wxMenu *arg1 = (wxMenu *) 0 ;
34516 int arg2 ;
34517 wxString result;
34518 PyObject * obj0 = 0 ;
34519 PyObject * obj1 = 0 ;
34520 char *kwnames[] = {
34521 (char *) "self",(char *) "id", NULL
34522 };
34523
34524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34526 if (SWIG_arg_fail(1)) SWIG_fail;
34527 {
34528 arg2 = (int)(SWIG_As_int(obj1));
34529 if (SWIG_arg_fail(2)) SWIG_fail;
34530 }
34531 {
34532 PyThreadState* __tstate = wxPyBeginAllowThreads();
34533 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34534
34535 wxPyEndAllowThreads(__tstate);
34536 if (PyErr_Occurred()) SWIG_fail;
34537 }
34538 {
34539 #if wxUSE_UNICODE
34540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34541 #else
34542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34543 #endif
34544 }
34545 return resultobj;
34546 fail:
34547 return NULL;
34548 }
34549
34550
34551 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34552 PyObject *resultobj;
34553 wxMenu *arg1 = (wxMenu *) 0 ;
34554 wxString *arg2 = 0 ;
34555 bool temp2 = false ;
34556 PyObject * obj0 = 0 ;
34557 PyObject * obj1 = 0 ;
34558 char *kwnames[] = {
34559 (char *) "self",(char *) "title", NULL
34560 };
34561
34562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34564 if (SWIG_arg_fail(1)) SWIG_fail;
34565 {
34566 arg2 = wxString_in_helper(obj1);
34567 if (arg2 == NULL) SWIG_fail;
34568 temp2 = true;
34569 }
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 (arg1)->SetTitle((wxString const &)*arg2);
34573
34574 wxPyEndAllowThreads(__tstate);
34575 if (PyErr_Occurred()) SWIG_fail;
34576 }
34577 Py_INCREF(Py_None); resultobj = Py_None;
34578 {
34579 if (temp2)
34580 delete arg2;
34581 }
34582 return resultobj;
34583 fail:
34584 {
34585 if (temp2)
34586 delete arg2;
34587 }
34588 return NULL;
34589 }
34590
34591
34592 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34593 PyObject *resultobj;
34594 wxMenu *arg1 = (wxMenu *) 0 ;
34595 wxString result;
34596 PyObject * obj0 = 0 ;
34597 char *kwnames[] = {
34598 (char *) "self", NULL
34599 };
34600
34601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34603 if (SWIG_arg_fail(1)) SWIG_fail;
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 result = ((wxMenu const *)arg1)->GetTitle();
34607
34608 wxPyEndAllowThreads(__tstate);
34609 if (PyErr_Occurred()) SWIG_fail;
34610 }
34611 {
34612 #if wxUSE_UNICODE
34613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34614 #else
34615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34616 #endif
34617 }
34618 return resultobj;
34619 fail:
34620 return NULL;
34621 }
34622
34623
34624 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34625 PyObject *resultobj;
34626 wxMenu *arg1 = (wxMenu *) 0 ;
34627 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34628 PyObject * obj0 = 0 ;
34629 PyObject * obj1 = 0 ;
34630 char *kwnames[] = {
34631 (char *) "self",(char *) "handler", NULL
34632 };
34633
34634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34636 if (SWIG_arg_fail(1)) SWIG_fail;
34637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34638 if (SWIG_arg_fail(2)) SWIG_fail;
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 (arg1)->SetEventHandler(arg2);
34642
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 Py_INCREF(Py_None); resultobj = Py_None;
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj;
34655 wxMenu *arg1 = (wxMenu *) 0 ;
34656 wxEvtHandler *result;
34657 PyObject * obj0 = 0 ;
34658 char *kwnames[] = {
34659 (char *) "self", NULL
34660 };
34661
34662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34664 if (SWIG_arg_fail(1)) SWIG_fail;
34665 {
34666 PyThreadState* __tstate = wxPyBeginAllowThreads();
34667 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34668
34669 wxPyEndAllowThreads(__tstate);
34670 if (PyErr_Occurred()) SWIG_fail;
34671 }
34672 {
34673 resultobj = wxPyMake_wxObject(result, 0);
34674 }
34675 return resultobj;
34676 fail:
34677 return NULL;
34678 }
34679
34680
34681 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34682 PyObject *resultobj;
34683 wxMenu *arg1 = (wxMenu *) 0 ;
34684 wxWindow *arg2 = (wxWindow *) 0 ;
34685 PyObject * obj0 = 0 ;
34686 PyObject * obj1 = 0 ;
34687 char *kwnames[] = {
34688 (char *) "self",(char *) "win", NULL
34689 };
34690
34691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34693 if (SWIG_arg_fail(1)) SWIG_fail;
34694 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34695 if (SWIG_arg_fail(2)) SWIG_fail;
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 (arg1)->SetInvokingWindow(arg2);
34699
34700 wxPyEndAllowThreads(__tstate);
34701 if (PyErr_Occurred()) SWIG_fail;
34702 }
34703 Py_INCREF(Py_None); resultobj = Py_None;
34704 return resultobj;
34705 fail:
34706 return NULL;
34707 }
34708
34709
34710 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34711 PyObject *resultobj;
34712 wxMenu *arg1 = (wxMenu *) 0 ;
34713 wxWindow *result;
34714 PyObject * obj0 = 0 ;
34715 char *kwnames[] = {
34716 (char *) "self", NULL
34717 };
34718
34719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34721 if (SWIG_arg_fail(1)) SWIG_fail;
34722 {
34723 PyThreadState* __tstate = wxPyBeginAllowThreads();
34724 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34725
34726 wxPyEndAllowThreads(__tstate);
34727 if (PyErr_Occurred()) SWIG_fail;
34728 }
34729 {
34730 resultobj = wxPyMake_wxObject(result, 0);
34731 }
34732 return resultobj;
34733 fail:
34734 return NULL;
34735 }
34736
34737
34738 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34739 PyObject *resultobj;
34740 wxMenu *arg1 = (wxMenu *) 0 ;
34741 long result;
34742 PyObject * obj0 = 0 ;
34743 char *kwnames[] = {
34744 (char *) "self", NULL
34745 };
34746
34747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34749 if (SWIG_arg_fail(1)) SWIG_fail;
34750 {
34751 PyThreadState* __tstate = wxPyBeginAllowThreads();
34752 result = (long)((wxMenu const *)arg1)->GetStyle();
34753
34754 wxPyEndAllowThreads(__tstate);
34755 if (PyErr_Occurred()) SWIG_fail;
34756 }
34757 {
34758 resultobj = SWIG_From_long((long)(result));
34759 }
34760 return resultobj;
34761 fail:
34762 return NULL;
34763 }
34764
34765
34766 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34767 PyObject *resultobj;
34768 wxMenu *arg1 = (wxMenu *) 0 ;
34769 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34770 PyObject * obj0 = 0 ;
34771 PyObject * obj1 = 0 ;
34772 char *kwnames[] = {
34773 (char *) "self",(char *) "source", NULL
34774 };
34775
34776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34778 if (SWIG_arg_fail(1)) SWIG_fail;
34779 if (obj1) {
34780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34781 if (SWIG_arg_fail(2)) SWIG_fail;
34782 }
34783 {
34784 PyThreadState* __tstate = wxPyBeginAllowThreads();
34785 (arg1)->UpdateUI(arg2);
34786
34787 wxPyEndAllowThreads(__tstate);
34788 if (PyErr_Occurred()) SWIG_fail;
34789 }
34790 Py_INCREF(Py_None); resultobj = Py_None;
34791 return resultobj;
34792 fail:
34793 return NULL;
34794 }
34795
34796
34797 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34798 PyObject *resultobj;
34799 wxMenu *arg1 = (wxMenu *) 0 ;
34800 wxMenuBar *result;
34801 PyObject * obj0 = 0 ;
34802 char *kwnames[] = {
34803 (char *) "self", NULL
34804 };
34805
34806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34808 if (SWIG_arg_fail(1)) SWIG_fail;
34809 {
34810 PyThreadState* __tstate = wxPyBeginAllowThreads();
34811 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34812
34813 wxPyEndAllowThreads(__tstate);
34814 if (PyErr_Occurred()) SWIG_fail;
34815 }
34816 {
34817 resultobj = wxPyMake_wxObject(result, 0);
34818 }
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34826 PyObject *resultobj;
34827 wxMenu *arg1 = (wxMenu *) 0 ;
34828 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34829 PyObject * obj0 = 0 ;
34830 PyObject * obj1 = 0 ;
34831 char *kwnames[] = {
34832 (char *) "self",(char *) "menubar", NULL
34833 };
34834
34835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34837 if (SWIG_arg_fail(1)) SWIG_fail;
34838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34839 if (SWIG_arg_fail(2)) SWIG_fail;
34840 {
34841 PyThreadState* __tstate = wxPyBeginAllowThreads();
34842 (arg1)->Attach(arg2);
34843
34844 wxPyEndAllowThreads(__tstate);
34845 if (PyErr_Occurred()) SWIG_fail;
34846 }
34847 Py_INCREF(Py_None); resultobj = Py_None;
34848 return resultobj;
34849 fail:
34850 return NULL;
34851 }
34852
34853
34854 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34855 PyObject *resultobj;
34856 wxMenu *arg1 = (wxMenu *) 0 ;
34857 PyObject * obj0 = 0 ;
34858 char *kwnames[] = {
34859 (char *) "self", NULL
34860 };
34861
34862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34864 if (SWIG_arg_fail(1)) SWIG_fail;
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 (arg1)->Detach();
34868
34869 wxPyEndAllowThreads(__tstate);
34870 if (PyErr_Occurred()) SWIG_fail;
34871 }
34872 Py_INCREF(Py_None); resultobj = Py_None;
34873 return resultobj;
34874 fail:
34875 return NULL;
34876 }
34877
34878
34879 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34880 PyObject *resultobj;
34881 wxMenu *arg1 = (wxMenu *) 0 ;
34882 bool result;
34883 PyObject * obj0 = 0 ;
34884 char *kwnames[] = {
34885 (char *) "self", NULL
34886 };
34887
34888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34890 if (SWIG_arg_fail(1)) SWIG_fail;
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 result = (bool)((wxMenu const *)arg1)->IsAttached();
34894
34895 wxPyEndAllowThreads(__tstate);
34896 if (PyErr_Occurred()) SWIG_fail;
34897 }
34898 {
34899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34900 }
34901 return resultobj;
34902 fail:
34903 return NULL;
34904 }
34905
34906
34907 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34908 PyObject *resultobj;
34909 wxMenu *arg1 = (wxMenu *) 0 ;
34910 wxMenu *arg2 = (wxMenu *) 0 ;
34911 PyObject * obj0 = 0 ;
34912 PyObject * obj1 = 0 ;
34913 char *kwnames[] = {
34914 (char *) "self",(char *) "parent", NULL
34915 };
34916
34917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34919 if (SWIG_arg_fail(1)) SWIG_fail;
34920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34921 if (SWIG_arg_fail(2)) SWIG_fail;
34922 {
34923 PyThreadState* __tstate = wxPyBeginAllowThreads();
34924 (arg1)->SetParent(arg2);
34925
34926 wxPyEndAllowThreads(__tstate);
34927 if (PyErr_Occurred()) SWIG_fail;
34928 }
34929 Py_INCREF(Py_None); resultobj = Py_None;
34930 return resultobj;
34931 fail:
34932 return NULL;
34933 }
34934
34935
34936 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34937 PyObject *resultobj;
34938 wxMenu *arg1 = (wxMenu *) 0 ;
34939 wxMenu *result;
34940 PyObject * obj0 = 0 ;
34941 char *kwnames[] = {
34942 (char *) "self", NULL
34943 };
34944
34945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34947 if (SWIG_arg_fail(1)) SWIG_fail;
34948 {
34949 PyThreadState* __tstate = wxPyBeginAllowThreads();
34950 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34951
34952 wxPyEndAllowThreads(__tstate);
34953 if (PyErr_Occurred()) SWIG_fail;
34954 }
34955 {
34956 resultobj = wxPyMake_wxObject(result, 0);
34957 }
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34965 PyObject *obj;
34966 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34967 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34968 Py_INCREF(obj);
34969 return Py_BuildValue((char *)"");
34970 }
34971 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34972 PyObject *resultobj;
34973 long arg1 = (long) 0 ;
34974 wxMenuBar *result;
34975 PyObject * obj0 = 0 ;
34976 char *kwnames[] = {
34977 (char *) "style", NULL
34978 };
34979
34980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34981 if (obj0) {
34982 {
34983 arg1 = (long)(SWIG_As_long(obj0));
34984 if (SWIG_arg_fail(1)) SWIG_fail;
34985 }
34986 }
34987 {
34988 if (!wxPyCheckForApp()) SWIG_fail;
34989 PyThreadState* __tstate = wxPyBeginAllowThreads();
34990 result = (wxMenuBar *)new wxMenuBar(arg1);
34991
34992 wxPyEndAllowThreads(__tstate);
34993 if (PyErr_Occurred()) SWIG_fail;
34994 }
34995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34996 return resultobj;
34997 fail:
34998 return NULL;
34999 }
35000
35001
35002 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35003 PyObject *resultobj;
35004 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35005 wxMenu *arg2 = (wxMenu *) 0 ;
35006 wxString *arg3 = 0 ;
35007 bool result;
35008 bool temp3 = false ;
35009 PyObject * obj0 = 0 ;
35010 PyObject * obj1 = 0 ;
35011 PyObject * obj2 = 0 ;
35012 char *kwnames[] = {
35013 (char *) "self",(char *) "menu",(char *) "title", NULL
35014 };
35015
35016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35018 if (SWIG_arg_fail(1)) SWIG_fail;
35019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35020 if (SWIG_arg_fail(2)) SWIG_fail;
35021 {
35022 arg3 = wxString_in_helper(obj2);
35023 if (arg3 == NULL) SWIG_fail;
35024 temp3 = true;
35025 }
35026 {
35027 PyThreadState* __tstate = wxPyBeginAllowThreads();
35028 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35029
35030 wxPyEndAllowThreads(__tstate);
35031 if (PyErr_Occurred()) SWIG_fail;
35032 }
35033 {
35034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35035 }
35036 {
35037 if (temp3)
35038 delete arg3;
35039 }
35040 return resultobj;
35041 fail:
35042 {
35043 if (temp3)
35044 delete arg3;
35045 }
35046 return NULL;
35047 }
35048
35049
35050 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35051 PyObject *resultobj;
35052 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35053 size_t arg2 ;
35054 wxMenu *arg3 = (wxMenu *) 0 ;
35055 wxString *arg4 = 0 ;
35056 bool result;
35057 bool temp4 = false ;
35058 PyObject * obj0 = 0 ;
35059 PyObject * obj1 = 0 ;
35060 PyObject * obj2 = 0 ;
35061 PyObject * obj3 = 0 ;
35062 char *kwnames[] = {
35063 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35064 };
35065
35066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35068 if (SWIG_arg_fail(1)) SWIG_fail;
35069 {
35070 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35071 if (SWIG_arg_fail(2)) SWIG_fail;
35072 }
35073 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35074 if (SWIG_arg_fail(3)) SWIG_fail;
35075 {
35076 arg4 = wxString_in_helper(obj3);
35077 if (arg4 == NULL) SWIG_fail;
35078 temp4 = true;
35079 }
35080 {
35081 PyThreadState* __tstate = wxPyBeginAllowThreads();
35082 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35083
35084 wxPyEndAllowThreads(__tstate);
35085 if (PyErr_Occurred()) SWIG_fail;
35086 }
35087 {
35088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35089 }
35090 {
35091 if (temp4)
35092 delete arg4;
35093 }
35094 return resultobj;
35095 fail:
35096 {
35097 if (temp4)
35098 delete arg4;
35099 }
35100 return NULL;
35101 }
35102
35103
35104 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35105 PyObject *resultobj;
35106 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35107 size_t result;
35108 PyObject * obj0 = 0 ;
35109 char *kwnames[] = {
35110 (char *) "self", NULL
35111 };
35112
35113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35115 if (SWIG_arg_fail(1)) SWIG_fail;
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35119
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 {
35124 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35125 }
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35133 PyObject *resultobj;
35134 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35135 size_t arg2 ;
35136 wxMenu *result;
35137 PyObject * obj0 = 0 ;
35138 PyObject * obj1 = 0 ;
35139 char *kwnames[] = {
35140 (char *) "self",(char *) "pos", NULL
35141 };
35142
35143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35145 if (SWIG_arg_fail(1)) SWIG_fail;
35146 {
35147 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35148 if (SWIG_arg_fail(2)) SWIG_fail;
35149 }
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35153
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 {
35158 resultobj = wxPyMake_wxObject(result, 0);
35159 }
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35167 PyObject *resultobj;
35168 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35169 size_t arg2 ;
35170 wxMenu *arg3 = (wxMenu *) 0 ;
35171 wxString *arg4 = 0 ;
35172 wxMenu *result;
35173 bool temp4 = false ;
35174 PyObject * obj0 = 0 ;
35175 PyObject * obj1 = 0 ;
35176 PyObject * obj2 = 0 ;
35177 PyObject * obj3 = 0 ;
35178 char *kwnames[] = {
35179 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35180 };
35181
35182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35184 if (SWIG_arg_fail(1)) SWIG_fail;
35185 {
35186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35187 if (SWIG_arg_fail(2)) SWIG_fail;
35188 }
35189 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35190 if (SWIG_arg_fail(3)) SWIG_fail;
35191 {
35192 arg4 = wxString_in_helper(obj3);
35193 if (arg4 == NULL) SWIG_fail;
35194 temp4 = true;
35195 }
35196 {
35197 PyThreadState* __tstate = wxPyBeginAllowThreads();
35198 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35199
35200 wxPyEndAllowThreads(__tstate);
35201 if (PyErr_Occurred()) SWIG_fail;
35202 }
35203 {
35204 resultobj = wxPyMake_wxObject(result, 0);
35205 }
35206 {
35207 if (temp4)
35208 delete arg4;
35209 }
35210 return resultobj;
35211 fail:
35212 {
35213 if (temp4)
35214 delete arg4;
35215 }
35216 return NULL;
35217 }
35218
35219
35220 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj;
35222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35223 size_t arg2 ;
35224 wxMenu *result;
35225 PyObject * obj0 = 0 ;
35226 PyObject * obj1 = 0 ;
35227 char *kwnames[] = {
35228 (char *) "self",(char *) "pos", NULL
35229 };
35230
35231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35233 if (SWIG_arg_fail(1)) SWIG_fail;
35234 {
35235 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35236 if (SWIG_arg_fail(2)) SWIG_fail;
35237 }
35238 {
35239 PyThreadState* __tstate = wxPyBeginAllowThreads();
35240 result = (wxMenu *)(arg1)->Remove(arg2);
35241
35242 wxPyEndAllowThreads(__tstate);
35243 if (PyErr_Occurred()) SWIG_fail;
35244 }
35245 {
35246 resultobj = wxPyMake_wxObject(result, 0);
35247 }
35248 return resultobj;
35249 fail:
35250 return NULL;
35251 }
35252
35253
35254 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35255 PyObject *resultobj;
35256 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35257 size_t arg2 ;
35258 bool arg3 ;
35259 PyObject * obj0 = 0 ;
35260 PyObject * obj1 = 0 ;
35261 PyObject * obj2 = 0 ;
35262 char *kwnames[] = {
35263 (char *) "self",(char *) "pos",(char *) "enable", NULL
35264 };
35265
35266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35268 if (SWIG_arg_fail(1)) SWIG_fail;
35269 {
35270 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35271 if (SWIG_arg_fail(2)) SWIG_fail;
35272 }
35273 {
35274 arg3 = (bool)(SWIG_As_bool(obj2));
35275 if (SWIG_arg_fail(3)) SWIG_fail;
35276 }
35277 {
35278 PyThreadState* __tstate = wxPyBeginAllowThreads();
35279 (arg1)->EnableTop(arg2,arg3);
35280
35281 wxPyEndAllowThreads(__tstate);
35282 if (PyErr_Occurred()) SWIG_fail;
35283 }
35284 Py_INCREF(Py_None); resultobj = Py_None;
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35292 PyObject *resultobj;
35293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35294 size_t arg2 ;
35295 bool result;
35296 PyObject * obj0 = 0 ;
35297 PyObject * obj1 = 0 ;
35298 char *kwnames[] = {
35299 (char *) "self",(char *) "pos", NULL
35300 };
35301
35302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35304 if (SWIG_arg_fail(1)) SWIG_fail;
35305 {
35306 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35307 if (SWIG_arg_fail(2)) SWIG_fail;
35308 }
35309 {
35310 PyThreadState* __tstate = wxPyBeginAllowThreads();
35311 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35312
35313 wxPyEndAllowThreads(__tstate);
35314 if (PyErr_Occurred()) SWIG_fail;
35315 }
35316 {
35317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35318 }
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35326 PyObject *resultobj;
35327 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35328 size_t arg2 ;
35329 wxString *arg3 = 0 ;
35330 bool temp3 = false ;
35331 PyObject * obj0 = 0 ;
35332 PyObject * obj1 = 0 ;
35333 PyObject * obj2 = 0 ;
35334 char *kwnames[] = {
35335 (char *) "self",(char *) "pos",(char *) "label", NULL
35336 };
35337
35338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35340 if (SWIG_arg_fail(1)) SWIG_fail;
35341 {
35342 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35343 if (SWIG_arg_fail(2)) SWIG_fail;
35344 }
35345 {
35346 arg3 = wxString_in_helper(obj2);
35347 if (arg3 == NULL) SWIG_fail;
35348 temp3 = true;
35349 }
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35353
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 Py_INCREF(Py_None); resultobj = Py_None;
35358 {
35359 if (temp3)
35360 delete arg3;
35361 }
35362 return resultobj;
35363 fail:
35364 {
35365 if (temp3)
35366 delete arg3;
35367 }
35368 return NULL;
35369 }
35370
35371
35372 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35373 PyObject *resultobj;
35374 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35375 size_t arg2 ;
35376 wxString result;
35377 PyObject * obj0 = 0 ;
35378 PyObject * obj1 = 0 ;
35379 char *kwnames[] = {
35380 (char *) "self",(char *) "pos", NULL
35381 };
35382
35383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35385 if (SWIG_arg_fail(1)) SWIG_fail;
35386 {
35387 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35388 if (SWIG_arg_fail(2)) SWIG_fail;
35389 }
35390 {
35391 PyThreadState* __tstate = wxPyBeginAllowThreads();
35392 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35393
35394 wxPyEndAllowThreads(__tstate);
35395 if (PyErr_Occurred()) SWIG_fail;
35396 }
35397 {
35398 #if wxUSE_UNICODE
35399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35400 #else
35401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35402 #endif
35403 }
35404 return resultobj;
35405 fail:
35406 return NULL;
35407 }
35408
35409
35410 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35411 PyObject *resultobj;
35412 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35413 wxString *arg2 = 0 ;
35414 wxString *arg3 = 0 ;
35415 int result;
35416 bool temp2 = false ;
35417 bool temp3 = false ;
35418 PyObject * obj0 = 0 ;
35419 PyObject * obj1 = 0 ;
35420 PyObject * obj2 = 0 ;
35421 char *kwnames[] = {
35422 (char *) "self",(char *) "menu",(char *) "item", NULL
35423 };
35424
35425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35427 if (SWIG_arg_fail(1)) SWIG_fail;
35428 {
35429 arg2 = wxString_in_helper(obj1);
35430 if (arg2 == NULL) SWIG_fail;
35431 temp2 = true;
35432 }
35433 {
35434 arg3 = wxString_in_helper(obj2);
35435 if (arg3 == NULL) SWIG_fail;
35436 temp3 = true;
35437 }
35438 {
35439 PyThreadState* __tstate = wxPyBeginAllowThreads();
35440 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35441
35442 wxPyEndAllowThreads(__tstate);
35443 if (PyErr_Occurred()) SWIG_fail;
35444 }
35445 {
35446 resultobj = SWIG_From_int((int)(result));
35447 }
35448 {
35449 if (temp2)
35450 delete arg2;
35451 }
35452 {
35453 if (temp3)
35454 delete arg3;
35455 }
35456 return resultobj;
35457 fail:
35458 {
35459 if (temp2)
35460 delete arg2;
35461 }
35462 {
35463 if (temp3)
35464 delete arg3;
35465 }
35466 return NULL;
35467 }
35468
35469
35470 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35471 PyObject *resultobj;
35472 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35473 int arg2 ;
35474 wxMenuItem *result;
35475 PyObject * obj0 = 0 ;
35476 PyObject * obj1 = 0 ;
35477 char *kwnames[] = {
35478 (char *) "self",(char *) "id", NULL
35479 };
35480
35481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35483 if (SWIG_arg_fail(1)) SWIG_fail;
35484 {
35485 arg2 = (int)(SWIG_As_int(obj1));
35486 if (SWIG_arg_fail(2)) SWIG_fail;
35487 }
35488 {
35489 PyThreadState* __tstate = wxPyBeginAllowThreads();
35490 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35491
35492 wxPyEndAllowThreads(__tstate);
35493 if (PyErr_Occurred()) SWIG_fail;
35494 }
35495 {
35496 resultobj = wxPyMake_wxObject(result, 0);
35497 }
35498 return resultobj;
35499 fail:
35500 return NULL;
35501 }
35502
35503
35504 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35505 PyObject *resultobj;
35506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35507 wxString *arg2 = 0 ;
35508 int result;
35509 bool temp2 = false ;
35510 PyObject * obj0 = 0 ;
35511 PyObject * obj1 = 0 ;
35512 char *kwnames[] = {
35513 (char *) "self",(char *) "title", NULL
35514 };
35515
35516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35518 if (SWIG_arg_fail(1)) SWIG_fail;
35519 {
35520 arg2 = wxString_in_helper(obj1);
35521 if (arg2 == NULL) SWIG_fail;
35522 temp2 = true;
35523 }
35524 {
35525 PyThreadState* __tstate = wxPyBeginAllowThreads();
35526 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35527
35528 wxPyEndAllowThreads(__tstate);
35529 if (PyErr_Occurred()) SWIG_fail;
35530 }
35531 {
35532 resultobj = SWIG_From_int((int)(result));
35533 }
35534 {
35535 if (temp2)
35536 delete arg2;
35537 }
35538 return resultobj;
35539 fail:
35540 {
35541 if (temp2)
35542 delete arg2;
35543 }
35544 return NULL;
35545 }
35546
35547
35548 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35549 PyObject *resultobj;
35550 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35551 int arg2 ;
35552 bool arg3 ;
35553 PyObject * obj0 = 0 ;
35554 PyObject * obj1 = 0 ;
35555 PyObject * obj2 = 0 ;
35556 char *kwnames[] = {
35557 (char *) "self",(char *) "id",(char *) "enable", NULL
35558 };
35559
35560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35562 if (SWIG_arg_fail(1)) SWIG_fail;
35563 {
35564 arg2 = (int)(SWIG_As_int(obj1));
35565 if (SWIG_arg_fail(2)) SWIG_fail;
35566 }
35567 {
35568 arg3 = (bool)(SWIG_As_bool(obj2));
35569 if (SWIG_arg_fail(3)) SWIG_fail;
35570 }
35571 {
35572 PyThreadState* __tstate = wxPyBeginAllowThreads();
35573 (arg1)->Enable(arg2,arg3);
35574
35575 wxPyEndAllowThreads(__tstate);
35576 if (PyErr_Occurred()) SWIG_fail;
35577 }
35578 Py_INCREF(Py_None); resultobj = Py_None;
35579 return resultobj;
35580 fail:
35581 return NULL;
35582 }
35583
35584
35585 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35586 PyObject *resultobj;
35587 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35588 int arg2 ;
35589 bool arg3 ;
35590 PyObject * obj0 = 0 ;
35591 PyObject * obj1 = 0 ;
35592 PyObject * obj2 = 0 ;
35593 char *kwnames[] = {
35594 (char *) "self",(char *) "id",(char *) "check", NULL
35595 };
35596
35597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35599 if (SWIG_arg_fail(1)) SWIG_fail;
35600 {
35601 arg2 = (int)(SWIG_As_int(obj1));
35602 if (SWIG_arg_fail(2)) SWIG_fail;
35603 }
35604 {
35605 arg3 = (bool)(SWIG_As_bool(obj2));
35606 if (SWIG_arg_fail(3)) SWIG_fail;
35607 }
35608 {
35609 PyThreadState* __tstate = wxPyBeginAllowThreads();
35610 (arg1)->Check(arg2,arg3);
35611
35612 wxPyEndAllowThreads(__tstate);
35613 if (PyErr_Occurred()) SWIG_fail;
35614 }
35615 Py_INCREF(Py_None); resultobj = Py_None;
35616 return resultobj;
35617 fail:
35618 return NULL;
35619 }
35620
35621
35622 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35623 PyObject *resultobj;
35624 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35625 int arg2 ;
35626 bool result;
35627 PyObject * obj0 = 0 ;
35628 PyObject * obj1 = 0 ;
35629 char *kwnames[] = {
35630 (char *) "self",(char *) "id", NULL
35631 };
35632
35633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35635 if (SWIG_arg_fail(1)) SWIG_fail;
35636 {
35637 arg2 = (int)(SWIG_As_int(obj1));
35638 if (SWIG_arg_fail(2)) SWIG_fail;
35639 }
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35643
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 {
35648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35649 }
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35657 PyObject *resultobj;
35658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35659 int arg2 ;
35660 bool result;
35661 PyObject * obj0 = 0 ;
35662 PyObject * obj1 = 0 ;
35663 char *kwnames[] = {
35664 (char *) "self",(char *) "id", NULL
35665 };
35666
35667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35669 if (SWIG_arg_fail(1)) SWIG_fail;
35670 {
35671 arg2 = (int)(SWIG_As_int(obj1));
35672 if (SWIG_arg_fail(2)) SWIG_fail;
35673 }
35674 {
35675 PyThreadState* __tstate = wxPyBeginAllowThreads();
35676 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35677
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 {
35682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35683 }
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35691 PyObject *resultobj;
35692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35693 int arg2 ;
35694 wxString *arg3 = 0 ;
35695 bool temp3 = false ;
35696 PyObject * obj0 = 0 ;
35697 PyObject * obj1 = 0 ;
35698 PyObject * obj2 = 0 ;
35699 char *kwnames[] = {
35700 (char *) "self",(char *) "id",(char *) "label", NULL
35701 };
35702
35703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35705 if (SWIG_arg_fail(1)) SWIG_fail;
35706 {
35707 arg2 = (int)(SWIG_As_int(obj1));
35708 if (SWIG_arg_fail(2)) SWIG_fail;
35709 }
35710 {
35711 arg3 = wxString_in_helper(obj2);
35712 if (arg3 == NULL) SWIG_fail;
35713 temp3 = true;
35714 }
35715 {
35716 PyThreadState* __tstate = wxPyBeginAllowThreads();
35717 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35718
35719 wxPyEndAllowThreads(__tstate);
35720 if (PyErr_Occurred()) SWIG_fail;
35721 }
35722 Py_INCREF(Py_None); resultobj = Py_None;
35723 {
35724 if (temp3)
35725 delete arg3;
35726 }
35727 return resultobj;
35728 fail:
35729 {
35730 if (temp3)
35731 delete arg3;
35732 }
35733 return NULL;
35734 }
35735
35736
35737 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35738 PyObject *resultobj;
35739 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35740 int arg2 ;
35741 wxString result;
35742 PyObject * obj0 = 0 ;
35743 PyObject * obj1 = 0 ;
35744 char *kwnames[] = {
35745 (char *) "self",(char *) "id", NULL
35746 };
35747
35748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35750 if (SWIG_arg_fail(1)) SWIG_fail;
35751 {
35752 arg2 = (int)(SWIG_As_int(obj1));
35753 if (SWIG_arg_fail(2)) SWIG_fail;
35754 }
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35758
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 {
35763 #if wxUSE_UNICODE
35764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35765 #else
35766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35767 #endif
35768 }
35769 return resultobj;
35770 fail:
35771 return NULL;
35772 }
35773
35774
35775 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35776 PyObject *resultobj;
35777 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35778 int arg2 ;
35779 wxString *arg3 = 0 ;
35780 bool temp3 = false ;
35781 PyObject * obj0 = 0 ;
35782 PyObject * obj1 = 0 ;
35783 PyObject * obj2 = 0 ;
35784 char *kwnames[] = {
35785 (char *) "self",(char *) "id",(char *) "helpString", NULL
35786 };
35787
35788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35790 if (SWIG_arg_fail(1)) SWIG_fail;
35791 {
35792 arg2 = (int)(SWIG_As_int(obj1));
35793 if (SWIG_arg_fail(2)) SWIG_fail;
35794 }
35795 {
35796 arg3 = wxString_in_helper(obj2);
35797 if (arg3 == NULL) SWIG_fail;
35798 temp3 = true;
35799 }
35800 {
35801 PyThreadState* __tstate = wxPyBeginAllowThreads();
35802 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35803
35804 wxPyEndAllowThreads(__tstate);
35805 if (PyErr_Occurred()) SWIG_fail;
35806 }
35807 Py_INCREF(Py_None); resultobj = Py_None;
35808 {
35809 if (temp3)
35810 delete arg3;
35811 }
35812 return resultobj;
35813 fail:
35814 {
35815 if (temp3)
35816 delete arg3;
35817 }
35818 return NULL;
35819 }
35820
35821
35822 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35823 PyObject *resultobj;
35824 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35825 int arg2 ;
35826 wxString result;
35827 PyObject * obj0 = 0 ;
35828 PyObject * obj1 = 0 ;
35829 char *kwnames[] = {
35830 (char *) "self",(char *) "id", NULL
35831 };
35832
35833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35835 if (SWIG_arg_fail(1)) SWIG_fail;
35836 {
35837 arg2 = (int)(SWIG_As_int(obj1));
35838 if (SWIG_arg_fail(2)) SWIG_fail;
35839 }
35840 {
35841 PyThreadState* __tstate = wxPyBeginAllowThreads();
35842 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35843
35844 wxPyEndAllowThreads(__tstate);
35845 if (PyErr_Occurred()) SWIG_fail;
35846 }
35847 {
35848 #if wxUSE_UNICODE
35849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35850 #else
35851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35852 #endif
35853 }
35854 return resultobj;
35855 fail:
35856 return NULL;
35857 }
35858
35859
35860 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35861 PyObject *resultobj;
35862 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35863 wxFrame *result;
35864 PyObject * obj0 = 0 ;
35865 char *kwnames[] = {
35866 (char *) "self", NULL
35867 };
35868
35869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35871 if (SWIG_arg_fail(1)) SWIG_fail;
35872 {
35873 PyThreadState* __tstate = wxPyBeginAllowThreads();
35874 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35875
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 {
35880 resultobj = wxPyMake_wxObject(result, 0);
35881 }
35882 return resultobj;
35883 fail:
35884 return NULL;
35885 }
35886
35887
35888 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35889 PyObject *resultobj;
35890 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35891 bool result;
35892 PyObject * obj0 = 0 ;
35893 char *kwnames[] = {
35894 (char *) "self", NULL
35895 };
35896
35897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35899 if (SWIG_arg_fail(1)) SWIG_fail;
35900 {
35901 PyThreadState* __tstate = wxPyBeginAllowThreads();
35902 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35903
35904 wxPyEndAllowThreads(__tstate);
35905 if (PyErr_Occurred()) SWIG_fail;
35906 }
35907 {
35908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35909 }
35910 return resultobj;
35911 fail:
35912 return NULL;
35913 }
35914
35915
35916 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35917 PyObject *resultobj;
35918 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35919 wxFrame *arg2 = (wxFrame *) 0 ;
35920 PyObject * obj0 = 0 ;
35921 PyObject * obj1 = 0 ;
35922 char *kwnames[] = {
35923 (char *) "self",(char *) "frame", NULL
35924 };
35925
35926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35928 if (SWIG_arg_fail(1)) SWIG_fail;
35929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35930 if (SWIG_arg_fail(2)) SWIG_fail;
35931 {
35932 PyThreadState* __tstate = wxPyBeginAllowThreads();
35933 (arg1)->Attach(arg2);
35934
35935 wxPyEndAllowThreads(__tstate);
35936 if (PyErr_Occurred()) SWIG_fail;
35937 }
35938 Py_INCREF(Py_None); resultobj = Py_None;
35939 return resultobj;
35940 fail:
35941 return NULL;
35942 }
35943
35944
35945 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35946 PyObject *resultobj;
35947 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35948 PyObject * obj0 = 0 ;
35949 char *kwnames[] = {
35950 (char *) "self", NULL
35951 };
35952
35953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35955 if (SWIG_arg_fail(1)) SWIG_fail;
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 (arg1)->Detach();
35959
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 Py_INCREF(Py_None); resultobj = Py_None;
35964 return resultobj;
35965 fail:
35966 return NULL;
35967 }
35968
35969
35970 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35971 PyObject *resultobj;
35972 bool arg1 ;
35973 PyObject * obj0 = 0 ;
35974 char *kwnames[] = {
35975 (char *) "enable", NULL
35976 };
35977
35978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
35979 {
35980 arg1 = (bool)(SWIG_As_bool(obj0));
35981 if (SWIG_arg_fail(1)) SWIG_fail;
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 MenuBar_SetAutoWindowMenu(arg1);
35986
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 Py_INCREF(Py_None); resultobj = Py_None;
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35998 PyObject *resultobj;
35999 bool result;
36000 char *kwnames[] = {
36001 NULL
36002 };
36003
36004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36005 {
36006 PyThreadState* __tstate = wxPyBeginAllowThreads();
36007 result = (bool)MenuBar_GetAutoWindowMenu();
36008
36009 wxPyEndAllowThreads(__tstate);
36010 if (PyErr_Occurred()) SWIG_fail;
36011 }
36012 {
36013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36014 }
36015 return resultobj;
36016 fail:
36017 return NULL;
36018 }
36019
36020
36021 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36022 PyObject *obj;
36023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36024 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36025 Py_INCREF(obj);
36026 return Py_BuildValue((char *)"");
36027 }
36028 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36029 PyObject *resultobj;
36030 wxMenu *arg1 = (wxMenu *) NULL ;
36031 int arg2 = (int) wxID_ANY ;
36032 wxString const &arg3_defvalue = wxPyEmptyString ;
36033 wxString *arg3 = (wxString *) &arg3_defvalue ;
36034 wxString const &arg4_defvalue = wxPyEmptyString ;
36035 wxString *arg4 = (wxString *) &arg4_defvalue ;
36036 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36037 wxMenu *arg6 = (wxMenu *) NULL ;
36038 wxMenuItem *result;
36039 bool temp3 = false ;
36040 bool temp4 = false ;
36041 PyObject * obj0 = 0 ;
36042 PyObject * obj1 = 0 ;
36043 PyObject * obj2 = 0 ;
36044 PyObject * obj3 = 0 ;
36045 PyObject * obj4 = 0 ;
36046 PyObject * obj5 = 0 ;
36047 char *kwnames[] = {
36048 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36049 };
36050
36051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36052 if (obj0) {
36053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36054 if (SWIG_arg_fail(1)) SWIG_fail;
36055 }
36056 if (obj1) {
36057 {
36058 arg2 = (int)(SWIG_As_int(obj1));
36059 if (SWIG_arg_fail(2)) SWIG_fail;
36060 }
36061 }
36062 if (obj2) {
36063 {
36064 arg3 = wxString_in_helper(obj2);
36065 if (arg3 == NULL) SWIG_fail;
36066 temp3 = true;
36067 }
36068 }
36069 if (obj3) {
36070 {
36071 arg4 = wxString_in_helper(obj3);
36072 if (arg4 == NULL) SWIG_fail;
36073 temp4 = true;
36074 }
36075 }
36076 if (obj4) {
36077 {
36078 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36079 if (SWIG_arg_fail(5)) SWIG_fail;
36080 }
36081 }
36082 if (obj5) {
36083 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36084 if (SWIG_arg_fail(6)) SWIG_fail;
36085 }
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36089
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 {
36094 resultobj = wxPyMake_wxObject(result, 1);
36095 }
36096 {
36097 if (temp3)
36098 delete arg3;
36099 }
36100 {
36101 if (temp4)
36102 delete arg4;
36103 }
36104 return resultobj;
36105 fail:
36106 {
36107 if (temp3)
36108 delete arg3;
36109 }
36110 {
36111 if (temp4)
36112 delete arg4;
36113 }
36114 return NULL;
36115 }
36116
36117
36118 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36119 PyObject *resultobj;
36120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36121 wxMenu *result;
36122 PyObject * obj0 = 0 ;
36123 char *kwnames[] = {
36124 (char *) "self", NULL
36125 };
36126
36127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36129 if (SWIG_arg_fail(1)) SWIG_fail;
36130 {
36131 PyThreadState* __tstate = wxPyBeginAllowThreads();
36132 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36133
36134 wxPyEndAllowThreads(__tstate);
36135 if (PyErr_Occurred()) SWIG_fail;
36136 }
36137 {
36138 resultobj = wxPyMake_wxObject(result, 0);
36139 }
36140 return resultobj;
36141 fail:
36142 return NULL;
36143 }
36144
36145
36146 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36147 PyObject *resultobj;
36148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36149 wxMenu *arg2 = (wxMenu *) 0 ;
36150 PyObject * obj0 = 0 ;
36151 PyObject * obj1 = 0 ;
36152 char *kwnames[] = {
36153 (char *) "self",(char *) "menu", NULL
36154 };
36155
36156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36158 if (SWIG_arg_fail(1)) SWIG_fail;
36159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36160 if (SWIG_arg_fail(2)) SWIG_fail;
36161 {
36162 PyThreadState* __tstate = wxPyBeginAllowThreads();
36163 (arg1)->SetMenu(arg2);
36164
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 Py_INCREF(Py_None); resultobj = Py_None;
36169 return resultobj;
36170 fail:
36171 return NULL;
36172 }
36173
36174
36175 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36176 PyObject *resultobj;
36177 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36178 int arg2 ;
36179 PyObject * obj0 = 0 ;
36180 PyObject * obj1 = 0 ;
36181 char *kwnames[] = {
36182 (char *) "self",(char *) "id", NULL
36183 };
36184
36185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36187 if (SWIG_arg_fail(1)) SWIG_fail;
36188 {
36189 arg2 = (int)(SWIG_As_int(obj1));
36190 if (SWIG_arg_fail(2)) SWIG_fail;
36191 }
36192 {
36193 PyThreadState* __tstate = wxPyBeginAllowThreads();
36194 (arg1)->SetId(arg2);
36195
36196 wxPyEndAllowThreads(__tstate);
36197 if (PyErr_Occurred()) SWIG_fail;
36198 }
36199 Py_INCREF(Py_None); resultobj = Py_None;
36200 return resultobj;
36201 fail:
36202 return NULL;
36203 }
36204
36205
36206 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36207 PyObject *resultobj;
36208 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36209 int result;
36210 PyObject * obj0 = 0 ;
36211 char *kwnames[] = {
36212 (char *) "self", NULL
36213 };
36214
36215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36217 if (SWIG_arg_fail(1)) SWIG_fail;
36218 {
36219 PyThreadState* __tstate = wxPyBeginAllowThreads();
36220 result = (int)((wxMenuItem const *)arg1)->GetId();
36221
36222 wxPyEndAllowThreads(__tstate);
36223 if (PyErr_Occurred()) SWIG_fail;
36224 }
36225 {
36226 resultobj = SWIG_From_int((int)(result));
36227 }
36228 return resultobj;
36229 fail:
36230 return NULL;
36231 }
36232
36233
36234 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36235 PyObject *resultobj;
36236 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36237 bool result;
36238 PyObject * obj0 = 0 ;
36239 char *kwnames[] = {
36240 (char *) "self", NULL
36241 };
36242
36243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36245 if (SWIG_arg_fail(1)) SWIG_fail;
36246 {
36247 PyThreadState* __tstate = wxPyBeginAllowThreads();
36248 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36249
36250 wxPyEndAllowThreads(__tstate);
36251 if (PyErr_Occurred()) SWIG_fail;
36252 }
36253 {
36254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36255 }
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36263 PyObject *resultobj;
36264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36265 wxString *arg2 = 0 ;
36266 bool temp2 = false ;
36267 PyObject * obj0 = 0 ;
36268 PyObject * obj1 = 0 ;
36269 char *kwnames[] = {
36270 (char *) "self",(char *) "str", NULL
36271 };
36272
36273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
36278 if (arg2 == NULL) SWIG_fail;
36279 temp2 = true;
36280 }
36281 {
36282 PyThreadState* __tstate = wxPyBeginAllowThreads();
36283 (arg1)->SetText((wxString const &)*arg2);
36284
36285 wxPyEndAllowThreads(__tstate);
36286 if (PyErr_Occurred()) SWIG_fail;
36287 }
36288 Py_INCREF(Py_None); resultobj = Py_None;
36289 {
36290 if (temp2)
36291 delete arg2;
36292 }
36293 return resultobj;
36294 fail:
36295 {
36296 if (temp2)
36297 delete arg2;
36298 }
36299 return NULL;
36300 }
36301
36302
36303 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36304 PyObject *resultobj;
36305 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36306 wxString result;
36307 PyObject * obj0 = 0 ;
36308 char *kwnames[] = {
36309 (char *) "self", NULL
36310 };
36311
36312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36314 if (SWIG_arg_fail(1)) SWIG_fail;
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = ((wxMenuItem const *)arg1)->GetLabel();
36318
36319 wxPyEndAllowThreads(__tstate);
36320 if (PyErr_Occurred()) SWIG_fail;
36321 }
36322 {
36323 #if wxUSE_UNICODE
36324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36325 #else
36326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36327 #endif
36328 }
36329 return resultobj;
36330 fail:
36331 return NULL;
36332 }
36333
36334
36335 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36336 PyObject *resultobj;
36337 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36338 wxString *result;
36339 PyObject * obj0 = 0 ;
36340 char *kwnames[] = {
36341 (char *) "self", NULL
36342 };
36343
36344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36346 if (SWIG_arg_fail(1)) SWIG_fail;
36347 {
36348 PyThreadState* __tstate = wxPyBeginAllowThreads();
36349 {
36350 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36351 result = (wxString *) &_result_ref;
36352 }
36353
36354 wxPyEndAllowThreads(__tstate);
36355 if (PyErr_Occurred()) SWIG_fail;
36356 }
36357 {
36358 #if wxUSE_UNICODE
36359 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36360 #else
36361 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36362 #endif
36363 }
36364 return resultobj;
36365 fail:
36366 return NULL;
36367 }
36368
36369
36370 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36371 PyObject *resultobj;
36372 wxString *arg1 = 0 ;
36373 wxString result;
36374 bool temp1 = false ;
36375 PyObject * obj0 = 0 ;
36376 char *kwnames[] = {
36377 (char *) "text", NULL
36378 };
36379
36380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36381 {
36382 arg1 = wxString_in_helper(obj0);
36383 if (arg1 == NULL) SWIG_fail;
36384 temp1 = true;
36385 }
36386 {
36387 PyThreadState* __tstate = wxPyBeginAllowThreads();
36388 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36389
36390 wxPyEndAllowThreads(__tstate);
36391 if (PyErr_Occurred()) SWIG_fail;
36392 }
36393 {
36394 #if wxUSE_UNICODE
36395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36396 #else
36397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36398 #endif
36399 }
36400 {
36401 if (temp1)
36402 delete arg1;
36403 }
36404 return resultobj;
36405 fail:
36406 {
36407 if (temp1)
36408 delete arg1;
36409 }
36410 return NULL;
36411 }
36412
36413
36414 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36415 PyObject *resultobj;
36416 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36417 wxItemKind result;
36418 PyObject * obj0 = 0 ;
36419 char *kwnames[] = {
36420 (char *) "self", NULL
36421 };
36422
36423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36425 if (SWIG_arg_fail(1)) SWIG_fail;
36426 {
36427 PyThreadState* __tstate = wxPyBeginAllowThreads();
36428 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36429
36430 wxPyEndAllowThreads(__tstate);
36431 if (PyErr_Occurred()) SWIG_fail;
36432 }
36433 resultobj = SWIG_From_int((result));
36434 return resultobj;
36435 fail:
36436 return NULL;
36437 }
36438
36439
36440 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36441 PyObject *resultobj;
36442 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36443 wxItemKind arg2 ;
36444 PyObject * obj0 = 0 ;
36445 PyObject * obj1 = 0 ;
36446 char *kwnames[] = {
36447 (char *) "self",(char *) "kind", NULL
36448 };
36449
36450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36452 if (SWIG_arg_fail(1)) SWIG_fail;
36453 {
36454 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36455 if (SWIG_arg_fail(2)) SWIG_fail;
36456 }
36457 {
36458 PyThreadState* __tstate = wxPyBeginAllowThreads();
36459 (arg1)->SetKind((wxItemKind )arg2);
36460
36461 wxPyEndAllowThreads(__tstate);
36462 if (PyErr_Occurred()) SWIG_fail;
36463 }
36464 Py_INCREF(Py_None); resultobj = Py_None;
36465 return resultobj;
36466 fail:
36467 return NULL;
36468 }
36469
36470
36471 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36472 PyObject *resultobj;
36473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36474 bool arg2 ;
36475 PyObject * obj0 = 0 ;
36476 PyObject * obj1 = 0 ;
36477 char *kwnames[] = {
36478 (char *) "self",(char *) "checkable", NULL
36479 };
36480
36481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36483 if (SWIG_arg_fail(1)) SWIG_fail;
36484 {
36485 arg2 = (bool)(SWIG_As_bool(obj1));
36486 if (SWIG_arg_fail(2)) SWIG_fail;
36487 }
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 (arg1)->SetCheckable(arg2);
36491
36492 wxPyEndAllowThreads(__tstate);
36493 if (PyErr_Occurred()) SWIG_fail;
36494 }
36495 Py_INCREF(Py_None); resultobj = Py_None;
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36503 PyObject *resultobj;
36504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36505 bool result;
36506 PyObject * obj0 = 0 ;
36507 char *kwnames[] = {
36508 (char *) "self", NULL
36509 };
36510
36511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36513 if (SWIG_arg_fail(1)) SWIG_fail;
36514 {
36515 PyThreadState* __tstate = wxPyBeginAllowThreads();
36516 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36517
36518 wxPyEndAllowThreads(__tstate);
36519 if (PyErr_Occurred()) SWIG_fail;
36520 }
36521 {
36522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36523 }
36524 return resultobj;
36525 fail:
36526 return NULL;
36527 }
36528
36529
36530 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36531 PyObject *resultobj;
36532 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36533 bool result;
36534 PyObject * obj0 = 0 ;
36535 char *kwnames[] = {
36536 (char *) "self", NULL
36537 };
36538
36539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36541 if (SWIG_arg_fail(1)) SWIG_fail;
36542 {
36543 PyThreadState* __tstate = wxPyBeginAllowThreads();
36544 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36545
36546 wxPyEndAllowThreads(__tstate);
36547 if (PyErr_Occurred()) SWIG_fail;
36548 }
36549 {
36550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36551 }
36552 return resultobj;
36553 fail:
36554 return NULL;
36555 }
36556
36557
36558 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36559 PyObject *resultobj;
36560 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36561 wxMenu *arg2 = (wxMenu *) 0 ;
36562 PyObject * obj0 = 0 ;
36563 PyObject * obj1 = 0 ;
36564 char *kwnames[] = {
36565 (char *) "self",(char *) "menu", NULL
36566 };
36567
36568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36570 if (SWIG_arg_fail(1)) SWIG_fail;
36571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36572 if (SWIG_arg_fail(2)) SWIG_fail;
36573 {
36574 PyThreadState* __tstate = wxPyBeginAllowThreads();
36575 (arg1)->SetSubMenu(arg2);
36576
36577 wxPyEndAllowThreads(__tstate);
36578 if (PyErr_Occurred()) SWIG_fail;
36579 }
36580 Py_INCREF(Py_None); resultobj = Py_None;
36581 return resultobj;
36582 fail:
36583 return NULL;
36584 }
36585
36586
36587 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36588 PyObject *resultobj;
36589 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36590 wxMenu *result;
36591 PyObject * obj0 = 0 ;
36592 char *kwnames[] = {
36593 (char *) "self", NULL
36594 };
36595
36596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36598 if (SWIG_arg_fail(1)) SWIG_fail;
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36602
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 {
36607 resultobj = wxPyMake_wxObject(result, 0);
36608 }
36609 return resultobj;
36610 fail:
36611 return NULL;
36612 }
36613
36614
36615 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36616 PyObject *resultobj;
36617 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36618 bool arg2 = (bool) true ;
36619 PyObject * obj0 = 0 ;
36620 PyObject * obj1 = 0 ;
36621 char *kwnames[] = {
36622 (char *) "self",(char *) "enable", NULL
36623 };
36624
36625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) 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 if (obj1) {
36629 {
36630 arg2 = (bool)(SWIG_As_bool(obj1));
36631 if (SWIG_arg_fail(2)) SWIG_fail;
36632 }
36633 }
36634 {
36635 PyThreadState* __tstate = wxPyBeginAllowThreads();
36636 (arg1)->Enable(arg2);
36637
36638 wxPyEndAllowThreads(__tstate);
36639 if (PyErr_Occurred()) SWIG_fail;
36640 }
36641 Py_INCREF(Py_None); resultobj = Py_None;
36642 return resultobj;
36643 fail:
36644 return NULL;
36645 }
36646
36647
36648 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36649 PyObject *resultobj;
36650 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36651 bool result;
36652 PyObject * obj0 = 0 ;
36653 char *kwnames[] = {
36654 (char *) "self", NULL
36655 };
36656
36657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36659 if (SWIG_arg_fail(1)) SWIG_fail;
36660 {
36661 PyThreadState* __tstate = wxPyBeginAllowThreads();
36662 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36663
36664 wxPyEndAllowThreads(__tstate);
36665 if (PyErr_Occurred()) SWIG_fail;
36666 }
36667 {
36668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36669 }
36670 return resultobj;
36671 fail:
36672 return NULL;
36673 }
36674
36675
36676 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36677 PyObject *resultobj;
36678 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36679 bool arg2 = (bool) true ;
36680 PyObject * obj0 = 0 ;
36681 PyObject * obj1 = 0 ;
36682 char *kwnames[] = {
36683 (char *) "self",(char *) "check", NULL
36684 };
36685
36686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36688 if (SWIG_arg_fail(1)) SWIG_fail;
36689 if (obj1) {
36690 {
36691 arg2 = (bool)(SWIG_As_bool(obj1));
36692 if (SWIG_arg_fail(2)) SWIG_fail;
36693 }
36694 }
36695 {
36696 PyThreadState* __tstate = wxPyBeginAllowThreads();
36697 (arg1)->Check(arg2);
36698
36699 wxPyEndAllowThreads(__tstate);
36700 if (PyErr_Occurred()) SWIG_fail;
36701 }
36702 Py_INCREF(Py_None); resultobj = Py_None;
36703 return resultobj;
36704 fail:
36705 return NULL;
36706 }
36707
36708
36709 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36710 PyObject *resultobj;
36711 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36712 bool result;
36713 PyObject * obj0 = 0 ;
36714 char *kwnames[] = {
36715 (char *) "self", NULL
36716 };
36717
36718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36720 if (SWIG_arg_fail(1)) SWIG_fail;
36721 {
36722 PyThreadState* __tstate = wxPyBeginAllowThreads();
36723 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36724
36725 wxPyEndAllowThreads(__tstate);
36726 if (PyErr_Occurred()) SWIG_fail;
36727 }
36728 {
36729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36730 }
36731 return resultobj;
36732 fail:
36733 return NULL;
36734 }
36735
36736
36737 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36738 PyObject *resultobj;
36739 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36740 PyObject * obj0 = 0 ;
36741 char *kwnames[] = {
36742 (char *) "self", NULL
36743 };
36744
36745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36747 if (SWIG_arg_fail(1)) SWIG_fail;
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 (arg1)->Toggle();
36751
36752 wxPyEndAllowThreads(__tstate);
36753 if (PyErr_Occurred()) SWIG_fail;
36754 }
36755 Py_INCREF(Py_None); resultobj = Py_None;
36756 return resultobj;
36757 fail:
36758 return NULL;
36759 }
36760
36761
36762 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36763 PyObject *resultobj;
36764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36765 wxString *arg2 = 0 ;
36766 bool temp2 = false ;
36767 PyObject * obj0 = 0 ;
36768 PyObject * obj1 = 0 ;
36769 char *kwnames[] = {
36770 (char *) "self",(char *) "str", NULL
36771 };
36772
36773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36775 if (SWIG_arg_fail(1)) SWIG_fail;
36776 {
36777 arg2 = wxString_in_helper(obj1);
36778 if (arg2 == NULL) SWIG_fail;
36779 temp2 = true;
36780 }
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 (arg1)->SetHelp((wxString const &)*arg2);
36784
36785 wxPyEndAllowThreads(__tstate);
36786 if (PyErr_Occurred()) SWIG_fail;
36787 }
36788 Py_INCREF(Py_None); resultobj = Py_None;
36789 {
36790 if (temp2)
36791 delete arg2;
36792 }
36793 return resultobj;
36794 fail:
36795 {
36796 if (temp2)
36797 delete arg2;
36798 }
36799 return NULL;
36800 }
36801
36802
36803 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36804 PyObject *resultobj;
36805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36806 wxString *result;
36807 PyObject * obj0 = 0 ;
36808 char *kwnames[] = {
36809 (char *) "self", NULL
36810 };
36811
36812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36814 if (SWIG_arg_fail(1)) SWIG_fail;
36815 {
36816 PyThreadState* __tstate = wxPyBeginAllowThreads();
36817 {
36818 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36819 result = (wxString *) &_result_ref;
36820 }
36821
36822 wxPyEndAllowThreads(__tstate);
36823 if (PyErr_Occurred()) SWIG_fail;
36824 }
36825 {
36826 #if wxUSE_UNICODE
36827 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36828 #else
36829 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36830 #endif
36831 }
36832 return resultobj;
36833 fail:
36834 return NULL;
36835 }
36836
36837
36838 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36839 PyObject *resultobj;
36840 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36841 wxAcceleratorEntry *result;
36842 PyObject * obj0 = 0 ;
36843 char *kwnames[] = {
36844 (char *) "self", NULL
36845 };
36846
36847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36849 if (SWIG_arg_fail(1)) SWIG_fail;
36850 {
36851 PyThreadState* __tstate = wxPyBeginAllowThreads();
36852 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36853
36854 wxPyEndAllowThreads(__tstate);
36855 if (PyErr_Occurred()) SWIG_fail;
36856 }
36857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36858 return resultobj;
36859 fail:
36860 return NULL;
36861 }
36862
36863
36864 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36865 PyObject *resultobj;
36866 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36867 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36868 PyObject * obj0 = 0 ;
36869 PyObject * obj1 = 0 ;
36870 char *kwnames[] = {
36871 (char *) "self",(char *) "accel", NULL
36872 };
36873
36874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36876 if (SWIG_arg_fail(1)) SWIG_fail;
36877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36878 if (SWIG_arg_fail(2)) SWIG_fail;
36879 {
36880 PyThreadState* __tstate = wxPyBeginAllowThreads();
36881 (arg1)->SetAccel(arg2);
36882
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 Py_INCREF(Py_None); resultobj = Py_None;
36887 return resultobj;
36888 fail:
36889 return NULL;
36890 }
36891
36892
36893 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36894 PyObject *resultobj;
36895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36896 wxFont *arg2 = 0 ;
36897 PyObject * obj0 = 0 ;
36898 PyObject * obj1 = 0 ;
36899 char *kwnames[] = {
36900 (char *) "self",(char *) "font", NULL
36901 };
36902
36903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36905 if (SWIG_arg_fail(1)) SWIG_fail;
36906 {
36907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36908 if (SWIG_arg_fail(2)) SWIG_fail;
36909 if (arg2 == NULL) {
36910 SWIG_null_ref("wxFont");
36911 }
36912 if (SWIG_arg_fail(2)) SWIG_fail;
36913 }
36914 {
36915 PyThreadState* __tstate = wxPyBeginAllowThreads();
36916 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36917
36918 wxPyEndAllowThreads(__tstate);
36919 if (PyErr_Occurred()) SWIG_fail;
36920 }
36921 Py_INCREF(Py_None); resultobj = Py_None;
36922 return resultobj;
36923 fail:
36924 return NULL;
36925 }
36926
36927
36928 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36929 PyObject *resultobj;
36930 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36931 wxFont result;
36932 PyObject * obj0 = 0 ;
36933 char *kwnames[] = {
36934 (char *) "self", NULL
36935 };
36936
36937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36939 if (SWIG_arg_fail(1)) SWIG_fail;
36940 {
36941 PyThreadState* __tstate = wxPyBeginAllowThreads();
36942 result = wxMenuItem_GetFont(arg1);
36943
36944 wxPyEndAllowThreads(__tstate);
36945 if (PyErr_Occurred()) SWIG_fail;
36946 }
36947 {
36948 wxFont * resultptr;
36949 resultptr = new wxFont((wxFont &)(result));
36950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36951 }
36952 return resultobj;
36953 fail:
36954 return NULL;
36955 }
36956
36957
36958 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36959 PyObject *resultobj;
36960 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36961 wxColour *arg2 = 0 ;
36962 wxColour temp2 ;
36963 PyObject * obj0 = 0 ;
36964 PyObject * obj1 = 0 ;
36965 char *kwnames[] = {
36966 (char *) "self",(char *) "colText", NULL
36967 };
36968
36969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36971 if (SWIG_arg_fail(1)) SWIG_fail;
36972 {
36973 arg2 = &temp2;
36974 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36975 }
36976 {
36977 PyThreadState* __tstate = wxPyBeginAllowThreads();
36978 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36979
36980 wxPyEndAllowThreads(__tstate);
36981 if (PyErr_Occurred()) SWIG_fail;
36982 }
36983 Py_INCREF(Py_None); resultobj = Py_None;
36984 return resultobj;
36985 fail:
36986 return NULL;
36987 }
36988
36989
36990 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36991 PyObject *resultobj;
36992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36993 wxColour result;
36994 PyObject * obj0 = 0 ;
36995 char *kwnames[] = {
36996 (char *) "self", NULL
36997 };
36998
36999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37001 if (SWIG_arg_fail(1)) SWIG_fail;
37002 {
37003 PyThreadState* __tstate = wxPyBeginAllowThreads();
37004 result = wxMenuItem_GetTextColour(arg1);
37005
37006 wxPyEndAllowThreads(__tstate);
37007 if (PyErr_Occurred()) SWIG_fail;
37008 }
37009 {
37010 wxColour * resultptr;
37011 resultptr = new wxColour((wxColour &)(result));
37012 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37013 }
37014 return resultobj;
37015 fail:
37016 return NULL;
37017 }
37018
37019
37020 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37021 PyObject *resultobj;
37022 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37023 wxColour *arg2 = 0 ;
37024 wxColour temp2 ;
37025 PyObject * obj0 = 0 ;
37026 PyObject * obj1 = 0 ;
37027 char *kwnames[] = {
37028 (char *) "self",(char *) "colBack", NULL
37029 };
37030
37031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37033 if (SWIG_arg_fail(1)) SWIG_fail;
37034 {
37035 arg2 = &temp2;
37036 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37037 }
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37041
37042 wxPyEndAllowThreads(__tstate);
37043 if (PyErr_Occurred()) SWIG_fail;
37044 }
37045 Py_INCREF(Py_None); resultobj = Py_None;
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37053 PyObject *resultobj;
37054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37055 wxColour result;
37056 PyObject * obj0 = 0 ;
37057 char *kwnames[] = {
37058 (char *) "self", NULL
37059 };
37060
37061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37063 if (SWIG_arg_fail(1)) SWIG_fail;
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = wxMenuItem_GetBackgroundColour(arg1);
37067
37068 wxPyEndAllowThreads(__tstate);
37069 if (PyErr_Occurred()) SWIG_fail;
37070 }
37071 {
37072 wxColour * resultptr;
37073 resultptr = new wxColour((wxColour &)(result));
37074 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37075 }
37076 return resultobj;
37077 fail:
37078 return NULL;
37079 }
37080
37081
37082 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37083 PyObject *resultobj;
37084 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37085 wxBitmap *arg2 = 0 ;
37086 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37087 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37088 PyObject * obj0 = 0 ;
37089 PyObject * obj1 = 0 ;
37090 PyObject * obj2 = 0 ;
37091 char *kwnames[] = {
37092 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37093 };
37094
37095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37097 if (SWIG_arg_fail(1)) SWIG_fail;
37098 {
37099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37100 if (SWIG_arg_fail(2)) SWIG_fail;
37101 if (arg2 == NULL) {
37102 SWIG_null_ref("wxBitmap");
37103 }
37104 if (SWIG_arg_fail(2)) SWIG_fail;
37105 }
37106 if (obj2) {
37107 {
37108 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37109 if (SWIG_arg_fail(3)) SWIG_fail;
37110 if (arg3 == NULL) {
37111 SWIG_null_ref("wxBitmap");
37112 }
37113 if (SWIG_arg_fail(3)) SWIG_fail;
37114 }
37115 }
37116 {
37117 PyThreadState* __tstate = wxPyBeginAllowThreads();
37118 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37119
37120 wxPyEndAllowThreads(__tstate);
37121 if (PyErr_Occurred()) SWIG_fail;
37122 }
37123 Py_INCREF(Py_None); resultobj = Py_None;
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj;
37132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37133 wxBitmap *arg2 = 0 ;
37134 PyObject * obj0 = 0 ;
37135 PyObject * obj1 = 0 ;
37136 char *kwnames[] = {
37137 (char *) "self",(char *) "bmpDisabled", NULL
37138 };
37139
37140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37142 if (SWIG_arg_fail(1)) SWIG_fail;
37143 {
37144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37145 if (SWIG_arg_fail(2)) SWIG_fail;
37146 if (arg2 == NULL) {
37147 SWIG_null_ref("wxBitmap");
37148 }
37149 if (SWIG_arg_fail(2)) SWIG_fail;
37150 }
37151 {
37152 PyThreadState* __tstate = wxPyBeginAllowThreads();
37153 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37154
37155 wxPyEndAllowThreads(__tstate);
37156 if (PyErr_Occurred()) SWIG_fail;
37157 }
37158 Py_INCREF(Py_None); resultobj = Py_None;
37159 return resultobj;
37160 fail:
37161 return NULL;
37162 }
37163
37164
37165 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37166 PyObject *resultobj;
37167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37168 wxBitmap *result;
37169 PyObject * obj0 = 0 ;
37170 char *kwnames[] = {
37171 (char *) "self", NULL
37172 };
37173
37174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37176 if (SWIG_arg_fail(1)) SWIG_fail;
37177 {
37178 PyThreadState* __tstate = wxPyBeginAllowThreads();
37179 {
37180 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37181 result = (wxBitmap *) &_result_ref;
37182 }
37183
37184 wxPyEndAllowThreads(__tstate);
37185 if (PyErr_Occurred()) SWIG_fail;
37186 }
37187 {
37188 wxBitmap* resultptr = new wxBitmap(*result);
37189 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37190 }
37191 return resultobj;
37192 fail:
37193 return NULL;
37194 }
37195
37196
37197 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37198 PyObject *resultobj;
37199 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37200 int arg2 ;
37201 PyObject * obj0 = 0 ;
37202 PyObject * obj1 = 0 ;
37203 char *kwnames[] = {
37204 (char *) "self",(char *) "nWidth", NULL
37205 };
37206
37207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37209 if (SWIG_arg_fail(1)) SWIG_fail;
37210 {
37211 arg2 = (int)(SWIG_As_int(obj1));
37212 if (SWIG_arg_fail(2)) SWIG_fail;
37213 }
37214 {
37215 PyThreadState* __tstate = wxPyBeginAllowThreads();
37216 wxMenuItem_SetMarginWidth(arg1,arg2);
37217
37218 wxPyEndAllowThreads(__tstate);
37219 if (PyErr_Occurred()) SWIG_fail;
37220 }
37221 Py_INCREF(Py_None); resultobj = Py_None;
37222 return resultobj;
37223 fail:
37224 return NULL;
37225 }
37226
37227
37228 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37229 PyObject *resultobj;
37230 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37231 int result;
37232 PyObject * obj0 = 0 ;
37233 char *kwnames[] = {
37234 (char *) "self", NULL
37235 };
37236
37237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37239 if (SWIG_arg_fail(1)) SWIG_fail;
37240 {
37241 PyThreadState* __tstate = wxPyBeginAllowThreads();
37242 result = (int)wxMenuItem_GetMarginWidth(arg1);
37243
37244 wxPyEndAllowThreads(__tstate);
37245 if (PyErr_Occurred()) SWIG_fail;
37246 }
37247 {
37248 resultobj = SWIG_From_int((int)(result));
37249 }
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj;
37258 int result;
37259 char *kwnames[] = {
37260 NULL
37261 };
37262
37263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37264 {
37265 PyThreadState* __tstate = wxPyBeginAllowThreads();
37266 result = (int)MenuItem_GetDefaultMarginWidth();
37267
37268 wxPyEndAllowThreads(__tstate);
37269 if (PyErr_Occurred()) SWIG_fail;
37270 }
37271 {
37272 resultobj = SWIG_From_int((int)(result));
37273 }
37274 return resultobj;
37275 fail:
37276 return NULL;
37277 }
37278
37279
37280 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37281 PyObject *resultobj;
37282 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37283 bool result;
37284 PyObject * obj0 = 0 ;
37285 char *kwnames[] = {
37286 (char *) "self", NULL
37287 };
37288
37289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37291 if (SWIG_arg_fail(1)) SWIG_fail;
37292 {
37293 PyThreadState* __tstate = wxPyBeginAllowThreads();
37294 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37295
37296 wxPyEndAllowThreads(__tstate);
37297 if (PyErr_Occurred()) SWIG_fail;
37298 }
37299 {
37300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37301 }
37302 return resultobj;
37303 fail:
37304 return NULL;
37305 }
37306
37307
37308 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37309 PyObject *resultobj;
37310 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37311 bool arg2 = (bool) true ;
37312 PyObject * obj0 = 0 ;
37313 PyObject * obj1 = 0 ;
37314 char *kwnames[] = {
37315 (char *) "self",(char *) "ownerDrawn", NULL
37316 };
37317
37318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37320 if (SWIG_arg_fail(1)) SWIG_fail;
37321 if (obj1) {
37322 {
37323 arg2 = (bool)(SWIG_As_bool(obj1));
37324 if (SWIG_arg_fail(2)) SWIG_fail;
37325 }
37326 }
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37330
37331 wxPyEndAllowThreads(__tstate);
37332 if (PyErr_Occurred()) SWIG_fail;
37333 }
37334 Py_INCREF(Py_None); resultobj = Py_None;
37335 return resultobj;
37336 fail:
37337 return NULL;
37338 }
37339
37340
37341 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37342 PyObject *resultobj;
37343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37344 PyObject * obj0 = 0 ;
37345 char *kwnames[] = {
37346 (char *) "self", NULL
37347 };
37348
37349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37351 if (SWIG_arg_fail(1)) SWIG_fail;
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 wxMenuItem_ResetOwnerDrawn(arg1);
37355
37356 wxPyEndAllowThreads(__tstate);
37357 if (PyErr_Occurred()) SWIG_fail;
37358 }
37359 Py_INCREF(Py_None); resultobj = Py_None;
37360 return resultobj;
37361 fail:
37362 return NULL;
37363 }
37364
37365
37366 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37367 PyObject *resultobj;
37368 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37369 wxBitmap *arg2 = 0 ;
37370 PyObject * obj0 = 0 ;
37371 PyObject * obj1 = 0 ;
37372 char *kwnames[] = {
37373 (char *) "self",(char *) "bitmap", NULL
37374 };
37375
37376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37378 if (SWIG_arg_fail(1)) SWIG_fail;
37379 {
37380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37381 if (SWIG_arg_fail(2)) SWIG_fail;
37382 if (arg2 == NULL) {
37383 SWIG_null_ref("wxBitmap");
37384 }
37385 if (SWIG_arg_fail(2)) SWIG_fail;
37386 }
37387 {
37388 PyThreadState* __tstate = wxPyBeginAllowThreads();
37389 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37390
37391 wxPyEndAllowThreads(__tstate);
37392 if (PyErr_Occurred()) SWIG_fail;
37393 }
37394 Py_INCREF(Py_None); resultobj = Py_None;
37395 return resultobj;
37396 fail:
37397 return NULL;
37398 }
37399
37400
37401 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37402 PyObject *resultobj;
37403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37404 wxBitmap *result;
37405 PyObject * obj0 = 0 ;
37406 char *kwnames[] = {
37407 (char *) "self", NULL
37408 };
37409
37410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37412 if (SWIG_arg_fail(1)) SWIG_fail;
37413 {
37414 PyThreadState* __tstate = wxPyBeginAllowThreads();
37415 {
37416 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37417 result = (wxBitmap *) &_result_ref;
37418 }
37419
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 {
37424 wxBitmap* resultptr = new wxBitmap(*result);
37425 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37426 }
37427 return resultobj;
37428 fail:
37429 return NULL;
37430 }
37431
37432
37433 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37434 PyObject *obj;
37435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37436 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37437 Py_INCREF(obj);
37438 return Py_BuildValue((char *)"");
37439 }
37440 static int _wrap_ControlNameStr_set(PyObject *) {
37441 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37442 return 1;
37443 }
37444
37445
37446 static PyObject *_wrap_ControlNameStr_get(void) {
37447 PyObject *pyobj;
37448
37449 {
37450 #if wxUSE_UNICODE
37451 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37452 #else
37453 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37454 #endif
37455 }
37456 return pyobj;
37457 }
37458
37459
37460 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37461 PyObject *resultobj;
37462 wxWindow *arg1 = (wxWindow *) 0 ;
37463 int arg2 = (int) -1 ;
37464 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37465 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37466 wxSize const &arg4_defvalue = wxDefaultSize ;
37467 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37468 long arg5 = (long) 0 ;
37469 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37470 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37471 wxString const &arg7_defvalue = wxPyControlNameStr ;
37472 wxString *arg7 = (wxString *) &arg7_defvalue ;
37473 wxControl *result;
37474 wxPoint temp3 ;
37475 wxSize temp4 ;
37476 bool temp7 = false ;
37477 PyObject * obj0 = 0 ;
37478 PyObject * obj1 = 0 ;
37479 PyObject * obj2 = 0 ;
37480 PyObject * obj3 = 0 ;
37481 PyObject * obj4 = 0 ;
37482 PyObject * obj5 = 0 ;
37483 PyObject * obj6 = 0 ;
37484 char *kwnames[] = {
37485 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37486 };
37487
37488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37490 if (SWIG_arg_fail(1)) SWIG_fail;
37491 if (obj1) {
37492 {
37493 arg2 = (int)(SWIG_As_int(obj1));
37494 if (SWIG_arg_fail(2)) SWIG_fail;
37495 }
37496 }
37497 if (obj2) {
37498 {
37499 arg3 = &temp3;
37500 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37501 }
37502 }
37503 if (obj3) {
37504 {
37505 arg4 = &temp4;
37506 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37507 }
37508 }
37509 if (obj4) {
37510 {
37511 arg5 = (long)(SWIG_As_long(obj4));
37512 if (SWIG_arg_fail(5)) SWIG_fail;
37513 }
37514 }
37515 if (obj5) {
37516 {
37517 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37518 if (SWIG_arg_fail(6)) SWIG_fail;
37519 if (arg6 == NULL) {
37520 SWIG_null_ref("wxValidator");
37521 }
37522 if (SWIG_arg_fail(6)) SWIG_fail;
37523 }
37524 }
37525 if (obj6) {
37526 {
37527 arg7 = wxString_in_helper(obj6);
37528 if (arg7 == NULL) SWIG_fail;
37529 temp7 = true;
37530 }
37531 }
37532 {
37533 if (!wxPyCheckForApp()) SWIG_fail;
37534 PyThreadState* __tstate = wxPyBeginAllowThreads();
37535 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37536
37537 wxPyEndAllowThreads(__tstate);
37538 if (PyErr_Occurred()) SWIG_fail;
37539 }
37540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37541 {
37542 if (temp7)
37543 delete arg7;
37544 }
37545 return resultobj;
37546 fail:
37547 {
37548 if (temp7)
37549 delete arg7;
37550 }
37551 return NULL;
37552 }
37553
37554
37555 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37556 PyObject *resultobj;
37557 wxControl *result;
37558 char *kwnames[] = {
37559 NULL
37560 };
37561
37562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37563 {
37564 if (!wxPyCheckForApp()) SWIG_fail;
37565 PyThreadState* __tstate = wxPyBeginAllowThreads();
37566 result = (wxControl *)new wxControl();
37567
37568 wxPyEndAllowThreads(__tstate);
37569 if (PyErr_Occurred()) SWIG_fail;
37570 }
37571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37572 return resultobj;
37573 fail:
37574 return NULL;
37575 }
37576
37577
37578 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37579 PyObject *resultobj;
37580 wxControl *arg1 = (wxControl *) 0 ;
37581 wxWindow *arg2 = (wxWindow *) 0 ;
37582 int arg3 = (int) -1 ;
37583 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37584 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37585 wxSize const &arg5_defvalue = wxDefaultSize ;
37586 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37587 long arg6 = (long) 0 ;
37588 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37589 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37590 wxString const &arg8_defvalue = wxPyControlNameStr ;
37591 wxString *arg8 = (wxString *) &arg8_defvalue ;
37592 bool result;
37593 wxPoint temp4 ;
37594 wxSize temp5 ;
37595 bool temp8 = false ;
37596 PyObject * obj0 = 0 ;
37597 PyObject * obj1 = 0 ;
37598 PyObject * obj2 = 0 ;
37599 PyObject * obj3 = 0 ;
37600 PyObject * obj4 = 0 ;
37601 PyObject * obj5 = 0 ;
37602 PyObject * obj6 = 0 ;
37603 PyObject * obj7 = 0 ;
37604 char *kwnames[] = {
37605 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37606 };
37607
37608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37610 if (SWIG_arg_fail(1)) SWIG_fail;
37611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37612 if (SWIG_arg_fail(2)) SWIG_fail;
37613 if (obj2) {
37614 {
37615 arg3 = (int)(SWIG_As_int(obj2));
37616 if (SWIG_arg_fail(3)) SWIG_fail;
37617 }
37618 }
37619 if (obj3) {
37620 {
37621 arg4 = &temp4;
37622 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37623 }
37624 }
37625 if (obj4) {
37626 {
37627 arg5 = &temp5;
37628 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37629 }
37630 }
37631 if (obj5) {
37632 {
37633 arg6 = (long)(SWIG_As_long(obj5));
37634 if (SWIG_arg_fail(6)) SWIG_fail;
37635 }
37636 }
37637 if (obj6) {
37638 {
37639 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37640 if (SWIG_arg_fail(7)) SWIG_fail;
37641 if (arg7 == NULL) {
37642 SWIG_null_ref("wxValidator");
37643 }
37644 if (SWIG_arg_fail(7)) SWIG_fail;
37645 }
37646 }
37647 if (obj7) {
37648 {
37649 arg8 = wxString_in_helper(obj7);
37650 if (arg8 == NULL) SWIG_fail;
37651 temp8 = true;
37652 }
37653 }
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37657
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 {
37662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37663 }
37664 {
37665 if (temp8)
37666 delete arg8;
37667 }
37668 return resultobj;
37669 fail:
37670 {
37671 if (temp8)
37672 delete arg8;
37673 }
37674 return NULL;
37675 }
37676
37677
37678 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37679 PyObject *resultobj;
37680 wxControl *arg1 = (wxControl *) 0 ;
37681 wxCommandEvent *arg2 = 0 ;
37682 PyObject * obj0 = 0 ;
37683 PyObject * obj1 = 0 ;
37684 char *kwnames[] = {
37685 (char *) "self",(char *) "event", NULL
37686 };
37687
37688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37690 if (SWIG_arg_fail(1)) SWIG_fail;
37691 {
37692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37693 if (SWIG_arg_fail(2)) SWIG_fail;
37694 if (arg2 == NULL) {
37695 SWIG_null_ref("wxCommandEvent");
37696 }
37697 if (SWIG_arg_fail(2)) SWIG_fail;
37698 }
37699 {
37700 PyThreadState* __tstate = wxPyBeginAllowThreads();
37701 (arg1)->Command(*arg2);
37702
37703 wxPyEndAllowThreads(__tstate);
37704 if (PyErr_Occurred()) SWIG_fail;
37705 }
37706 Py_INCREF(Py_None); resultobj = Py_None;
37707 return resultobj;
37708 fail:
37709 return NULL;
37710 }
37711
37712
37713 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37714 PyObject *resultobj;
37715 wxControl *arg1 = (wxControl *) 0 ;
37716 wxString result;
37717 PyObject * obj0 = 0 ;
37718 char *kwnames[] = {
37719 (char *) "self", NULL
37720 };
37721
37722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37724 if (SWIG_arg_fail(1)) SWIG_fail;
37725 {
37726 PyThreadState* __tstate = wxPyBeginAllowThreads();
37727 result = (arg1)->GetLabel();
37728
37729 wxPyEndAllowThreads(__tstate);
37730 if (PyErr_Occurred()) SWIG_fail;
37731 }
37732 {
37733 #if wxUSE_UNICODE
37734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37735 #else
37736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37737 #endif
37738 }
37739 return resultobj;
37740 fail:
37741 return NULL;
37742 }
37743
37744
37745 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37746 PyObject *resultobj;
37747 wxControl *arg1 = (wxControl *) 0 ;
37748 wxString *arg2 = 0 ;
37749 bool temp2 = false ;
37750 PyObject * obj0 = 0 ;
37751 PyObject * obj1 = 0 ;
37752 char *kwnames[] = {
37753 (char *) "self",(char *) "label", NULL
37754 };
37755
37756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37758 if (SWIG_arg_fail(1)) SWIG_fail;
37759 {
37760 arg2 = wxString_in_helper(obj1);
37761 if (arg2 == NULL) SWIG_fail;
37762 temp2 = true;
37763 }
37764 {
37765 PyThreadState* __tstate = wxPyBeginAllowThreads();
37766 (arg1)->SetLabel((wxString const &)*arg2);
37767
37768 wxPyEndAllowThreads(__tstate);
37769 if (PyErr_Occurred()) SWIG_fail;
37770 }
37771 Py_INCREF(Py_None); resultobj = Py_None;
37772 {
37773 if (temp2)
37774 delete arg2;
37775 }
37776 return resultobj;
37777 fail:
37778 {
37779 if (temp2)
37780 delete arg2;
37781 }
37782 return NULL;
37783 }
37784
37785
37786 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37787 PyObject *resultobj;
37788 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37789 wxVisualAttributes result;
37790 PyObject * obj0 = 0 ;
37791 char *kwnames[] = {
37792 (char *) "variant", NULL
37793 };
37794
37795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37796 if (obj0) {
37797 {
37798 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37799 if (SWIG_arg_fail(1)) SWIG_fail;
37800 }
37801 }
37802 {
37803 if (!wxPyCheckForApp()) SWIG_fail;
37804 PyThreadState* __tstate = wxPyBeginAllowThreads();
37805 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37806
37807 wxPyEndAllowThreads(__tstate);
37808 if (PyErr_Occurred()) SWIG_fail;
37809 }
37810 {
37811 wxVisualAttributes * resultptr;
37812 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37814 }
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37822 PyObject *obj;
37823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37824 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37825 Py_INCREF(obj);
37826 return Py_BuildValue((char *)"");
37827 }
37828 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37829 PyObject *resultobj;
37830 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37831 wxString *arg2 = 0 ;
37832 PyObject *arg3 = (PyObject *) NULL ;
37833 int result;
37834 bool temp2 = false ;
37835 PyObject * obj0 = 0 ;
37836 PyObject * obj1 = 0 ;
37837 PyObject * obj2 = 0 ;
37838 char *kwnames[] = {
37839 (char *) "self",(char *) "item",(char *) "clientData", NULL
37840 };
37841
37842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37844 if (SWIG_arg_fail(1)) SWIG_fail;
37845 {
37846 arg2 = wxString_in_helper(obj1);
37847 if (arg2 == NULL) SWIG_fail;
37848 temp2 = true;
37849 }
37850 if (obj2) {
37851 arg3 = obj2;
37852 }
37853 {
37854 PyThreadState* __tstate = wxPyBeginAllowThreads();
37855 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37856
37857 wxPyEndAllowThreads(__tstate);
37858 if (PyErr_Occurred()) SWIG_fail;
37859 }
37860 {
37861 resultobj = SWIG_From_int((int)(result));
37862 }
37863 {
37864 if (temp2)
37865 delete arg2;
37866 }
37867 return resultobj;
37868 fail:
37869 {
37870 if (temp2)
37871 delete arg2;
37872 }
37873 return NULL;
37874 }
37875
37876
37877 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37878 PyObject *resultobj;
37879 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37880 wxArrayString *arg2 = 0 ;
37881 bool temp2 = false ;
37882 PyObject * obj0 = 0 ;
37883 PyObject * obj1 = 0 ;
37884 char *kwnames[] = {
37885 (char *) "self",(char *) "strings", NULL
37886 };
37887
37888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37890 if (SWIG_arg_fail(1)) SWIG_fail;
37891 {
37892 if (! PySequence_Check(obj1)) {
37893 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37894 SWIG_fail;
37895 }
37896 arg2 = new wxArrayString;
37897 temp2 = true;
37898 int i, len=PySequence_Length(obj1);
37899 for (i=0; i<len; i++) {
37900 PyObject* item = PySequence_GetItem(obj1, i);
37901 wxString* s = wxString_in_helper(item);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 arg2->Add(*s);
37904 delete s;
37905 Py_DECREF(item);
37906 }
37907 }
37908 {
37909 PyThreadState* __tstate = wxPyBeginAllowThreads();
37910 (arg1)->Append((wxArrayString const &)*arg2);
37911
37912 wxPyEndAllowThreads(__tstate);
37913 if (PyErr_Occurred()) SWIG_fail;
37914 }
37915 Py_INCREF(Py_None); resultobj = Py_None;
37916 {
37917 if (temp2) delete arg2;
37918 }
37919 return resultobj;
37920 fail:
37921 {
37922 if (temp2) delete arg2;
37923 }
37924 return NULL;
37925 }
37926
37927
37928 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37929 PyObject *resultobj;
37930 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37931 wxString *arg2 = 0 ;
37932 int arg3 ;
37933 PyObject *arg4 = (PyObject *) NULL ;
37934 int result;
37935 bool temp2 = false ;
37936 PyObject * obj0 = 0 ;
37937 PyObject * obj1 = 0 ;
37938 PyObject * obj2 = 0 ;
37939 PyObject * obj3 = 0 ;
37940 char *kwnames[] = {
37941 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37942 };
37943
37944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37946 if (SWIG_arg_fail(1)) SWIG_fail;
37947 {
37948 arg2 = wxString_in_helper(obj1);
37949 if (arg2 == NULL) SWIG_fail;
37950 temp2 = true;
37951 }
37952 {
37953 arg3 = (int)(SWIG_As_int(obj2));
37954 if (SWIG_arg_fail(3)) SWIG_fail;
37955 }
37956 if (obj3) {
37957 arg4 = obj3;
37958 }
37959 {
37960 PyThreadState* __tstate = wxPyBeginAllowThreads();
37961 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37962
37963 wxPyEndAllowThreads(__tstate);
37964 if (PyErr_Occurred()) SWIG_fail;
37965 }
37966 {
37967 resultobj = SWIG_From_int((int)(result));
37968 }
37969 {
37970 if (temp2)
37971 delete arg2;
37972 }
37973 return resultobj;
37974 fail:
37975 {
37976 if (temp2)
37977 delete arg2;
37978 }
37979 return NULL;
37980 }
37981
37982
37983 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37984 PyObject *resultobj;
37985 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37986 PyObject * obj0 = 0 ;
37987 char *kwnames[] = {
37988 (char *) "self", NULL
37989 };
37990
37991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37993 if (SWIG_arg_fail(1)) SWIG_fail;
37994 {
37995 PyThreadState* __tstate = wxPyBeginAllowThreads();
37996 (arg1)->Clear();
37997
37998 wxPyEndAllowThreads(__tstate);
37999 if (PyErr_Occurred()) SWIG_fail;
38000 }
38001 Py_INCREF(Py_None); resultobj = Py_None;
38002 return resultobj;
38003 fail:
38004 return NULL;
38005 }
38006
38007
38008 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj;
38010 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38011 int arg2 ;
38012 PyObject * obj0 = 0 ;
38013 PyObject * obj1 = 0 ;
38014 char *kwnames[] = {
38015 (char *) "self",(char *) "n", NULL
38016 };
38017
38018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38020 if (SWIG_arg_fail(1)) SWIG_fail;
38021 {
38022 arg2 = (int)(SWIG_As_int(obj1));
38023 if (SWIG_arg_fail(2)) SWIG_fail;
38024 }
38025 {
38026 PyThreadState* __tstate = wxPyBeginAllowThreads();
38027 (arg1)->Delete(arg2);
38028
38029 wxPyEndAllowThreads(__tstate);
38030 if (PyErr_Occurred()) SWIG_fail;
38031 }
38032 Py_INCREF(Py_None); resultobj = Py_None;
38033 return resultobj;
38034 fail:
38035 return NULL;
38036 }
38037
38038
38039 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38040 PyObject *resultobj;
38041 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38042 int arg2 ;
38043 PyObject *result;
38044 PyObject * obj0 = 0 ;
38045 PyObject * obj1 = 0 ;
38046 char *kwnames[] = {
38047 (char *) "self",(char *) "n", NULL
38048 };
38049
38050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38052 if (SWIG_arg_fail(1)) SWIG_fail;
38053 {
38054 arg2 = (int)(SWIG_As_int(obj1));
38055 if (SWIG_arg_fail(2)) SWIG_fail;
38056 }
38057 {
38058 PyThreadState* __tstate = wxPyBeginAllowThreads();
38059 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38060
38061 wxPyEndAllowThreads(__tstate);
38062 if (PyErr_Occurred()) SWIG_fail;
38063 }
38064 resultobj = result;
38065 return resultobj;
38066 fail:
38067 return NULL;
38068 }
38069
38070
38071 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38072 PyObject *resultobj;
38073 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38074 int arg2 ;
38075 PyObject *arg3 = (PyObject *) 0 ;
38076 PyObject * obj0 = 0 ;
38077 PyObject * obj1 = 0 ;
38078 PyObject * obj2 = 0 ;
38079 char *kwnames[] = {
38080 (char *) "self",(char *) "n",(char *) "clientData", NULL
38081 };
38082
38083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38085 if (SWIG_arg_fail(1)) SWIG_fail;
38086 {
38087 arg2 = (int)(SWIG_As_int(obj1));
38088 if (SWIG_arg_fail(2)) SWIG_fail;
38089 }
38090 arg3 = obj2;
38091 {
38092 PyThreadState* __tstate = wxPyBeginAllowThreads();
38093 wxItemContainer_SetClientData(arg1,arg2,arg3);
38094
38095 wxPyEndAllowThreads(__tstate);
38096 if (PyErr_Occurred()) SWIG_fail;
38097 }
38098 Py_INCREF(Py_None); resultobj = Py_None;
38099 return resultobj;
38100 fail:
38101 return NULL;
38102 }
38103
38104
38105 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38106 PyObject *resultobj;
38107 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38108 int result;
38109 PyObject * obj0 = 0 ;
38110 char *kwnames[] = {
38111 (char *) "self", NULL
38112 };
38113
38114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38116 if (SWIG_arg_fail(1)) SWIG_fail;
38117 {
38118 PyThreadState* __tstate = wxPyBeginAllowThreads();
38119 result = (int)((wxItemContainer const *)arg1)->GetCount();
38120
38121 wxPyEndAllowThreads(__tstate);
38122 if (PyErr_Occurred()) SWIG_fail;
38123 }
38124 {
38125 resultobj = SWIG_From_int((int)(result));
38126 }
38127 return resultobj;
38128 fail:
38129 return NULL;
38130 }
38131
38132
38133 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38134 PyObject *resultobj;
38135 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38136 bool result;
38137 PyObject * obj0 = 0 ;
38138 char *kwnames[] = {
38139 (char *) "self", NULL
38140 };
38141
38142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38144 if (SWIG_arg_fail(1)) SWIG_fail;
38145 {
38146 PyThreadState* __tstate = wxPyBeginAllowThreads();
38147 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38148
38149 wxPyEndAllowThreads(__tstate);
38150 if (PyErr_Occurred()) SWIG_fail;
38151 }
38152 {
38153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38154 }
38155 return resultobj;
38156 fail:
38157 return NULL;
38158 }
38159
38160
38161 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38162 PyObject *resultobj;
38163 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38164 int arg2 ;
38165 wxString result;
38166 PyObject * obj0 = 0 ;
38167 PyObject * obj1 = 0 ;
38168 char *kwnames[] = {
38169 (char *) "self",(char *) "n", NULL
38170 };
38171
38172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38174 if (SWIG_arg_fail(1)) SWIG_fail;
38175 {
38176 arg2 = (int)(SWIG_As_int(obj1));
38177 if (SWIG_arg_fail(2)) SWIG_fail;
38178 }
38179 {
38180 PyThreadState* __tstate = wxPyBeginAllowThreads();
38181 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38182
38183 wxPyEndAllowThreads(__tstate);
38184 if (PyErr_Occurred()) SWIG_fail;
38185 }
38186 {
38187 #if wxUSE_UNICODE
38188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38189 #else
38190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38191 #endif
38192 }
38193 return resultobj;
38194 fail:
38195 return NULL;
38196 }
38197
38198
38199 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38200 PyObject *resultobj;
38201 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38202 wxArrayString result;
38203 PyObject * obj0 = 0 ;
38204 char *kwnames[] = {
38205 (char *) "self", NULL
38206 };
38207
38208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38210 if (SWIG_arg_fail(1)) SWIG_fail;
38211 {
38212 PyThreadState* __tstate = wxPyBeginAllowThreads();
38213 result = ((wxItemContainer const *)arg1)->GetStrings();
38214
38215 wxPyEndAllowThreads(__tstate);
38216 if (PyErr_Occurred()) SWIG_fail;
38217 }
38218 {
38219 resultobj = wxArrayString2PyList_helper(result);
38220 }
38221 return resultobj;
38222 fail:
38223 return NULL;
38224 }
38225
38226
38227 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38228 PyObject *resultobj;
38229 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38230 int arg2 ;
38231 wxString *arg3 = 0 ;
38232 bool temp3 = false ;
38233 PyObject * obj0 = 0 ;
38234 PyObject * obj1 = 0 ;
38235 PyObject * obj2 = 0 ;
38236 char *kwnames[] = {
38237 (char *) "self",(char *) "n",(char *) "s", NULL
38238 };
38239
38240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38242 if (SWIG_arg_fail(1)) SWIG_fail;
38243 {
38244 arg2 = (int)(SWIG_As_int(obj1));
38245 if (SWIG_arg_fail(2)) SWIG_fail;
38246 }
38247 {
38248 arg3 = wxString_in_helper(obj2);
38249 if (arg3 == NULL) SWIG_fail;
38250 temp3 = true;
38251 }
38252 {
38253 PyThreadState* __tstate = wxPyBeginAllowThreads();
38254 (arg1)->SetString(arg2,(wxString const &)*arg3);
38255
38256 wxPyEndAllowThreads(__tstate);
38257 if (PyErr_Occurred()) SWIG_fail;
38258 }
38259 Py_INCREF(Py_None); resultobj = Py_None;
38260 {
38261 if (temp3)
38262 delete arg3;
38263 }
38264 return resultobj;
38265 fail:
38266 {
38267 if (temp3)
38268 delete arg3;
38269 }
38270 return NULL;
38271 }
38272
38273
38274 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38275 PyObject *resultobj;
38276 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38277 wxString *arg2 = 0 ;
38278 int result;
38279 bool temp2 = false ;
38280 PyObject * obj0 = 0 ;
38281 PyObject * obj1 = 0 ;
38282 char *kwnames[] = {
38283 (char *) "self",(char *) "s", NULL
38284 };
38285
38286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38288 if (SWIG_arg_fail(1)) SWIG_fail;
38289 {
38290 arg2 = wxString_in_helper(obj1);
38291 if (arg2 == NULL) SWIG_fail;
38292 temp2 = true;
38293 }
38294 {
38295 PyThreadState* __tstate = wxPyBeginAllowThreads();
38296 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38297
38298 wxPyEndAllowThreads(__tstate);
38299 if (PyErr_Occurred()) SWIG_fail;
38300 }
38301 {
38302 resultobj = SWIG_From_int((int)(result));
38303 }
38304 {
38305 if (temp2)
38306 delete arg2;
38307 }
38308 return resultobj;
38309 fail:
38310 {
38311 if (temp2)
38312 delete arg2;
38313 }
38314 return NULL;
38315 }
38316
38317
38318 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38319 PyObject *resultobj;
38320 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38321 int arg2 ;
38322 PyObject * obj0 = 0 ;
38323 PyObject * obj1 = 0 ;
38324 char *kwnames[] = {
38325 (char *) "self",(char *) "n", NULL
38326 };
38327
38328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38330 if (SWIG_arg_fail(1)) SWIG_fail;
38331 {
38332 arg2 = (int)(SWIG_As_int(obj1));
38333 if (SWIG_arg_fail(2)) SWIG_fail;
38334 }
38335 {
38336 PyThreadState* __tstate = wxPyBeginAllowThreads();
38337 (arg1)->SetSelection(arg2);
38338
38339 wxPyEndAllowThreads(__tstate);
38340 if (PyErr_Occurred()) SWIG_fail;
38341 }
38342 Py_INCREF(Py_None); resultobj = Py_None;
38343 return resultobj;
38344 fail:
38345 return NULL;
38346 }
38347
38348
38349 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38350 PyObject *resultobj;
38351 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38352 int result;
38353 PyObject * obj0 = 0 ;
38354 char *kwnames[] = {
38355 (char *) "self", NULL
38356 };
38357
38358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38360 if (SWIG_arg_fail(1)) SWIG_fail;
38361 {
38362 PyThreadState* __tstate = wxPyBeginAllowThreads();
38363 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38364
38365 wxPyEndAllowThreads(__tstate);
38366 if (PyErr_Occurred()) SWIG_fail;
38367 }
38368 {
38369 resultobj = SWIG_From_int((int)(result));
38370 }
38371 return resultobj;
38372 fail:
38373 return NULL;
38374 }
38375
38376
38377 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38378 PyObject *resultobj;
38379 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38380 wxString *arg2 = 0 ;
38381 bool result;
38382 bool temp2 = false ;
38383 PyObject * obj0 = 0 ;
38384 PyObject * obj1 = 0 ;
38385 char *kwnames[] = {
38386 (char *) "self",(char *) "s", NULL
38387 };
38388
38389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38391 if (SWIG_arg_fail(1)) SWIG_fail;
38392 {
38393 arg2 = wxString_in_helper(obj1);
38394 if (arg2 == NULL) SWIG_fail;
38395 temp2 = true;
38396 }
38397 {
38398 PyThreadState* __tstate = wxPyBeginAllowThreads();
38399 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38400
38401 wxPyEndAllowThreads(__tstate);
38402 if (PyErr_Occurred()) SWIG_fail;
38403 }
38404 {
38405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38406 }
38407 {
38408 if (temp2)
38409 delete arg2;
38410 }
38411 return resultobj;
38412 fail:
38413 {
38414 if (temp2)
38415 delete arg2;
38416 }
38417 return NULL;
38418 }
38419
38420
38421 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38422 PyObject *resultobj;
38423 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38424 wxString result;
38425 PyObject * obj0 = 0 ;
38426 char *kwnames[] = {
38427 (char *) "self", NULL
38428 };
38429
38430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38432 if (SWIG_arg_fail(1)) SWIG_fail;
38433 {
38434 PyThreadState* __tstate = wxPyBeginAllowThreads();
38435 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38436
38437 wxPyEndAllowThreads(__tstate);
38438 if (PyErr_Occurred()) SWIG_fail;
38439 }
38440 {
38441 #if wxUSE_UNICODE
38442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38443 #else
38444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38445 #endif
38446 }
38447 return resultobj;
38448 fail:
38449 return NULL;
38450 }
38451
38452
38453 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38454 PyObject *resultobj;
38455 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38456 int arg2 ;
38457 PyObject * obj0 = 0 ;
38458 PyObject * obj1 = 0 ;
38459 char *kwnames[] = {
38460 (char *) "self",(char *) "n", NULL
38461 };
38462
38463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38465 if (SWIG_arg_fail(1)) SWIG_fail;
38466 {
38467 arg2 = (int)(SWIG_As_int(obj1));
38468 if (SWIG_arg_fail(2)) SWIG_fail;
38469 }
38470 {
38471 PyThreadState* __tstate = wxPyBeginAllowThreads();
38472 (arg1)->Select(arg2);
38473
38474 wxPyEndAllowThreads(__tstate);
38475 if (PyErr_Occurred()) SWIG_fail;
38476 }
38477 Py_INCREF(Py_None); resultobj = Py_None;
38478 return resultobj;
38479 fail:
38480 return NULL;
38481 }
38482
38483
38484 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38485 PyObject *obj;
38486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38487 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38488 Py_INCREF(obj);
38489 return Py_BuildValue((char *)"");
38490 }
38491 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38492 PyObject *obj;
38493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38494 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38495 Py_INCREF(obj);
38496 return Py_BuildValue((char *)"");
38497 }
38498 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38499 PyObject *resultobj;
38500 wxSizerItem *result;
38501 char *kwnames[] = {
38502 NULL
38503 };
38504
38505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38506 {
38507 PyThreadState* __tstate = wxPyBeginAllowThreads();
38508 result = (wxSizerItem *)new wxSizerItem();
38509
38510 wxPyEndAllowThreads(__tstate);
38511 if (PyErr_Occurred()) SWIG_fail;
38512 }
38513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38514 return resultobj;
38515 fail:
38516 return NULL;
38517 }
38518
38519
38520 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38521 PyObject *resultobj;
38522 wxWindow *arg1 = (wxWindow *) 0 ;
38523 int arg2 ;
38524 int arg3 ;
38525 int arg4 ;
38526 PyObject *arg5 = (PyObject *) NULL ;
38527 wxSizerItem *result;
38528 PyObject * obj0 = 0 ;
38529 PyObject * obj1 = 0 ;
38530 PyObject * obj2 = 0 ;
38531 PyObject * obj3 = 0 ;
38532 PyObject * obj4 = 0 ;
38533 char *kwnames[] = {
38534 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38535 };
38536
38537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38539 if (SWIG_arg_fail(1)) SWIG_fail;
38540 {
38541 arg2 = (int)(SWIG_As_int(obj1));
38542 if (SWIG_arg_fail(2)) SWIG_fail;
38543 }
38544 {
38545 arg3 = (int)(SWIG_As_int(obj2));
38546 if (SWIG_arg_fail(3)) SWIG_fail;
38547 }
38548 {
38549 arg4 = (int)(SWIG_As_int(obj3));
38550 if (SWIG_arg_fail(4)) SWIG_fail;
38551 }
38552 if (obj4) {
38553 arg5 = obj4;
38554 }
38555 {
38556 PyThreadState* __tstate = wxPyBeginAllowThreads();
38557 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38558
38559 wxPyEndAllowThreads(__tstate);
38560 if (PyErr_Occurred()) SWIG_fail;
38561 }
38562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38563 return resultobj;
38564 fail:
38565 return NULL;
38566 }
38567
38568
38569 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38570 PyObject *resultobj;
38571 int arg1 ;
38572 int arg2 ;
38573 int arg3 ;
38574 int arg4 ;
38575 int arg5 ;
38576 PyObject *arg6 = (PyObject *) NULL ;
38577 wxSizerItem *result;
38578 PyObject * obj0 = 0 ;
38579 PyObject * obj1 = 0 ;
38580 PyObject * obj2 = 0 ;
38581 PyObject * obj3 = 0 ;
38582 PyObject * obj4 = 0 ;
38583 PyObject * obj5 = 0 ;
38584 char *kwnames[] = {
38585 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38586 };
38587
38588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38589 {
38590 arg1 = (int)(SWIG_As_int(obj0));
38591 if (SWIG_arg_fail(1)) SWIG_fail;
38592 }
38593 {
38594 arg2 = (int)(SWIG_As_int(obj1));
38595 if (SWIG_arg_fail(2)) SWIG_fail;
38596 }
38597 {
38598 arg3 = (int)(SWIG_As_int(obj2));
38599 if (SWIG_arg_fail(3)) SWIG_fail;
38600 }
38601 {
38602 arg4 = (int)(SWIG_As_int(obj3));
38603 if (SWIG_arg_fail(4)) SWIG_fail;
38604 }
38605 {
38606 arg5 = (int)(SWIG_As_int(obj4));
38607 if (SWIG_arg_fail(5)) SWIG_fail;
38608 }
38609 if (obj5) {
38610 arg6 = obj5;
38611 }
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38615
38616 wxPyEndAllowThreads(__tstate);
38617 if (PyErr_Occurred()) SWIG_fail;
38618 }
38619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj;
38628 wxSizer *arg1 = (wxSizer *) 0 ;
38629 int arg2 ;
38630 int arg3 ;
38631 int arg4 ;
38632 PyObject *arg5 = (PyObject *) NULL ;
38633 wxSizerItem *result;
38634 PyObject * obj0 = 0 ;
38635 PyObject * obj1 = 0 ;
38636 PyObject * obj2 = 0 ;
38637 PyObject * obj3 = 0 ;
38638 PyObject * obj4 = 0 ;
38639 char *kwnames[] = {
38640 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38641 };
38642
38643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38645 if (SWIG_arg_fail(1)) SWIG_fail;
38646 {
38647 arg2 = (int)(SWIG_As_int(obj1));
38648 if (SWIG_arg_fail(2)) SWIG_fail;
38649 }
38650 {
38651 arg3 = (int)(SWIG_As_int(obj2));
38652 if (SWIG_arg_fail(3)) SWIG_fail;
38653 }
38654 {
38655 arg4 = (int)(SWIG_As_int(obj3));
38656 if (SWIG_arg_fail(4)) SWIG_fail;
38657 }
38658 if (obj4) {
38659 arg5 = obj4;
38660 }
38661 {
38662 PyThreadState* __tstate = wxPyBeginAllowThreads();
38663 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38664
38665 wxPyEndAllowThreads(__tstate);
38666 if (PyErr_Occurred()) SWIG_fail;
38667 }
38668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38669 return resultobj;
38670 fail:
38671 return NULL;
38672 }
38673
38674
38675 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38676 PyObject *resultobj;
38677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38678 PyObject * obj0 = 0 ;
38679 char *kwnames[] = {
38680 (char *) "self", NULL
38681 };
38682
38683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38685 if (SWIG_arg_fail(1)) SWIG_fail;
38686 {
38687 PyThreadState* __tstate = wxPyBeginAllowThreads();
38688 (arg1)->DeleteWindows();
38689
38690 wxPyEndAllowThreads(__tstate);
38691 if (PyErr_Occurred()) SWIG_fail;
38692 }
38693 Py_INCREF(Py_None); resultobj = Py_None;
38694 return resultobj;
38695 fail:
38696 return NULL;
38697 }
38698
38699
38700 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38701 PyObject *resultobj;
38702 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38703 PyObject * obj0 = 0 ;
38704 char *kwnames[] = {
38705 (char *) "self", NULL
38706 };
38707
38708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38710 if (SWIG_arg_fail(1)) SWIG_fail;
38711 {
38712 PyThreadState* __tstate = wxPyBeginAllowThreads();
38713 (arg1)->DetachSizer();
38714
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 Py_INCREF(Py_None); resultobj = Py_None;
38719 return resultobj;
38720 fail:
38721 return NULL;
38722 }
38723
38724
38725 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38726 PyObject *resultobj;
38727 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38728 wxSize result;
38729 PyObject * obj0 = 0 ;
38730 char *kwnames[] = {
38731 (char *) "self", NULL
38732 };
38733
38734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38736 if (SWIG_arg_fail(1)) SWIG_fail;
38737 {
38738 PyThreadState* __tstate = wxPyBeginAllowThreads();
38739 result = (arg1)->GetSize();
38740
38741 wxPyEndAllowThreads(__tstate);
38742 if (PyErr_Occurred()) SWIG_fail;
38743 }
38744 {
38745 wxSize * resultptr;
38746 resultptr = new wxSize((wxSize &)(result));
38747 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38748 }
38749 return resultobj;
38750 fail:
38751 return NULL;
38752 }
38753
38754
38755 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38756 PyObject *resultobj;
38757 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38758 wxSize result;
38759 PyObject * obj0 = 0 ;
38760 char *kwnames[] = {
38761 (char *) "self", NULL
38762 };
38763
38764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38766 if (SWIG_arg_fail(1)) SWIG_fail;
38767 {
38768 PyThreadState* __tstate = wxPyBeginAllowThreads();
38769 result = (arg1)->CalcMin();
38770
38771 wxPyEndAllowThreads(__tstate);
38772 if (PyErr_Occurred()) SWIG_fail;
38773 }
38774 {
38775 wxSize * resultptr;
38776 resultptr = new wxSize((wxSize &)(result));
38777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38778 }
38779 return resultobj;
38780 fail:
38781 return NULL;
38782 }
38783
38784
38785 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38786 PyObject *resultobj;
38787 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38788 wxPoint arg2 ;
38789 wxSize arg3 ;
38790 PyObject * obj0 = 0 ;
38791 PyObject * obj1 = 0 ;
38792 PyObject * obj2 = 0 ;
38793 char *kwnames[] = {
38794 (char *) "self",(char *) "pos",(char *) "size", NULL
38795 };
38796
38797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38799 if (SWIG_arg_fail(1)) SWIG_fail;
38800 {
38801 wxPoint * argp;
38802 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38803 if (SWIG_arg_fail(2)) SWIG_fail;
38804 if (argp == NULL) {
38805 SWIG_null_ref("wxPoint");
38806 }
38807 if (SWIG_arg_fail(2)) SWIG_fail;
38808 arg2 = *argp;
38809 }
38810 {
38811 wxSize * argp;
38812 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38813 if (SWIG_arg_fail(3)) SWIG_fail;
38814 if (argp == NULL) {
38815 SWIG_null_ref("wxSize");
38816 }
38817 if (SWIG_arg_fail(3)) SWIG_fail;
38818 arg3 = *argp;
38819 }
38820 {
38821 PyThreadState* __tstate = wxPyBeginAllowThreads();
38822 (arg1)->SetDimension(arg2,arg3);
38823
38824 wxPyEndAllowThreads(__tstate);
38825 if (PyErr_Occurred()) SWIG_fail;
38826 }
38827 Py_INCREF(Py_None); resultobj = Py_None;
38828 return resultobj;
38829 fail:
38830 return NULL;
38831 }
38832
38833
38834 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38835 PyObject *resultobj;
38836 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38837 wxSize result;
38838 PyObject * obj0 = 0 ;
38839 char *kwnames[] = {
38840 (char *) "self", NULL
38841 };
38842
38843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38845 if (SWIG_arg_fail(1)) SWIG_fail;
38846 {
38847 PyThreadState* __tstate = wxPyBeginAllowThreads();
38848 result = (arg1)->GetMinSize();
38849
38850 wxPyEndAllowThreads(__tstate);
38851 if (PyErr_Occurred()) SWIG_fail;
38852 }
38853 {
38854 wxSize * resultptr;
38855 resultptr = new wxSize((wxSize &)(result));
38856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38857 }
38858 return resultobj;
38859 fail:
38860 return NULL;
38861 }
38862
38863
38864 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38865 PyObject *resultobj;
38866 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38867 wxSize result;
38868 PyObject * obj0 = 0 ;
38869 char *kwnames[] = {
38870 (char *) "self", NULL
38871 };
38872
38873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38875 if (SWIG_arg_fail(1)) SWIG_fail;
38876 {
38877 PyThreadState* __tstate = wxPyBeginAllowThreads();
38878 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38879
38880 wxPyEndAllowThreads(__tstate);
38881 if (PyErr_Occurred()) SWIG_fail;
38882 }
38883 {
38884 wxSize * resultptr;
38885 resultptr = new wxSize((wxSize &)(result));
38886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38887 }
38888 return resultobj;
38889 fail:
38890 return NULL;
38891 }
38892
38893
38894 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38895 PyObject *resultobj;
38896 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38897 int arg2 ;
38898 int arg3 ;
38899 PyObject * obj0 = 0 ;
38900 PyObject * obj1 = 0 ;
38901 PyObject * obj2 = 0 ;
38902 char *kwnames[] = {
38903 (char *) "self",(char *) "x",(char *) "y", NULL
38904 };
38905
38906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38908 if (SWIG_arg_fail(1)) SWIG_fail;
38909 {
38910 arg2 = (int)(SWIG_As_int(obj1));
38911 if (SWIG_arg_fail(2)) SWIG_fail;
38912 }
38913 {
38914 arg3 = (int)(SWIG_As_int(obj2));
38915 if (SWIG_arg_fail(3)) SWIG_fail;
38916 }
38917 {
38918 PyThreadState* __tstate = wxPyBeginAllowThreads();
38919 (arg1)->SetInitSize(arg2,arg3);
38920
38921 wxPyEndAllowThreads(__tstate);
38922 if (PyErr_Occurred()) SWIG_fail;
38923 }
38924 Py_INCREF(Py_None); resultobj = Py_None;
38925 return resultobj;
38926 fail:
38927 return NULL;
38928 }
38929
38930
38931 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38932 PyObject *resultobj;
38933 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38934 int arg2 ;
38935 int arg3 ;
38936 PyObject * obj0 = 0 ;
38937 PyObject * obj1 = 0 ;
38938 PyObject * obj2 = 0 ;
38939 char *kwnames[] = {
38940 (char *) "self",(char *) "width",(char *) "height", NULL
38941 };
38942
38943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38945 if (SWIG_arg_fail(1)) SWIG_fail;
38946 {
38947 arg2 = (int)(SWIG_As_int(obj1));
38948 if (SWIG_arg_fail(2)) SWIG_fail;
38949 }
38950 {
38951 arg3 = (int)(SWIG_As_int(obj2));
38952 if (SWIG_arg_fail(3)) SWIG_fail;
38953 }
38954 {
38955 PyThreadState* __tstate = wxPyBeginAllowThreads();
38956 (arg1)->SetRatio(arg2,arg3);
38957
38958 wxPyEndAllowThreads(__tstate);
38959 if (PyErr_Occurred()) SWIG_fail;
38960 }
38961 Py_INCREF(Py_None); resultobj = Py_None;
38962 return resultobj;
38963 fail:
38964 return NULL;
38965 }
38966
38967
38968 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38969 PyObject *resultobj;
38970 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38971 wxSize *arg2 = 0 ;
38972 wxSize temp2 ;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 char *kwnames[] = {
38976 (char *) "self",(char *) "size", NULL
38977 };
38978
38979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38981 if (SWIG_arg_fail(1)) SWIG_fail;
38982 {
38983 arg2 = &temp2;
38984 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38985 }
38986 {
38987 PyThreadState* __tstate = wxPyBeginAllowThreads();
38988 (arg1)->SetRatio((wxSize const &)*arg2);
38989
38990 wxPyEndAllowThreads(__tstate);
38991 if (PyErr_Occurred()) SWIG_fail;
38992 }
38993 Py_INCREF(Py_None); resultobj = Py_None;
38994 return resultobj;
38995 fail:
38996 return NULL;
38997 }
38998
38999
39000 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39001 PyObject *resultobj;
39002 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39003 float arg2 ;
39004 PyObject * obj0 = 0 ;
39005 PyObject * obj1 = 0 ;
39006 char *kwnames[] = {
39007 (char *) "self",(char *) "ratio", NULL
39008 };
39009
39010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39012 if (SWIG_arg_fail(1)) SWIG_fail;
39013 {
39014 arg2 = (float)(SWIG_As_float(obj1));
39015 if (SWIG_arg_fail(2)) SWIG_fail;
39016 }
39017 {
39018 PyThreadState* __tstate = wxPyBeginAllowThreads();
39019 (arg1)->SetRatio(arg2);
39020
39021 wxPyEndAllowThreads(__tstate);
39022 if (PyErr_Occurred()) SWIG_fail;
39023 }
39024 Py_INCREF(Py_None); resultobj = Py_None;
39025 return resultobj;
39026 fail:
39027 return NULL;
39028 }
39029
39030
39031 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39032 PyObject *resultobj;
39033 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39034 float result;
39035 PyObject * obj0 = 0 ;
39036 char *kwnames[] = {
39037 (char *) "self", NULL
39038 };
39039
39040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39042 if (SWIG_arg_fail(1)) SWIG_fail;
39043 {
39044 PyThreadState* __tstate = wxPyBeginAllowThreads();
39045 result = (float)(arg1)->GetRatio();
39046
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 {
39051 resultobj = SWIG_From_float((float)(result));
39052 }
39053 return resultobj;
39054 fail:
39055 return NULL;
39056 }
39057
39058
39059 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39060 PyObject *resultobj;
39061 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39062 wxRect result;
39063 PyObject * obj0 = 0 ;
39064 char *kwnames[] = {
39065 (char *) "self", NULL
39066 };
39067
39068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39070 if (SWIG_arg_fail(1)) SWIG_fail;
39071 {
39072 PyThreadState* __tstate = wxPyBeginAllowThreads();
39073 result = (arg1)->GetRect();
39074
39075 wxPyEndAllowThreads(__tstate);
39076 if (PyErr_Occurred()) SWIG_fail;
39077 }
39078 {
39079 wxRect * resultptr;
39080 resultptr = new wxRect((wxRect &)(result));
39081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39082 }
39083 return resultobj;
39084 fail:
39085 return NULL;
39086 }
39087
39088
39089 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39090 PyObject *resultobj;
39091 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39092 bool result;
39093 PyObject * obj0 = 0 ;
39094 char *kwnames[] = {
39095 (char *) "self", NULL
39096 };
39097
39098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39100 if (SWIG_arg_fail(1)) SWIG_fail;
39101 {
39102 PyThreadState* __tstate = wxPyBeginAllowThreads();
39103 result = (bool)(arg1)->IsWindow();
39104
39105 wxPyEndAllowThreads(__tstate);
39106 if (PyErr_Occurred()) SWIG_fail;
39107 }
39108 {
39109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39110 }
39111 return resultobj;
39112 fail:
39113 return NULL;
39114 }
39115
39116
39117 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39118 PyObject *resultobj;
39119 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39120 bool result;
39121 PyObject * obj0 = 0 ;
39122 char *kwnames[] = {
39123 (char *) "self", NULL
39124 };
39125
39126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39128 if (SWIG_arg_fail(1)) SWIG_fail;
39129 {
39130 PyThreadState* __tstate = wxPyBeginAllowThreads();
39131 result = (bool)(arg1)->IsSizer();
39132
39133 wxPyEndAllowThreads(__tstate);
39134 if (PyErr_Occurred()) SWIG_fail;
39135 }
39136 {
39137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39138 }
39139 return resultobj;
39140 fail:
39141 return NULL;
39142 }
39143
39144
39145 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39146 PyObject *resultobj;
39147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39148 bool result;
39149 PyObject * obj0 = 0 ;
39150 char *kwnames[] = {
39151 (char *) "self", NULL
39152 };
39153
39154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39156 if (SWIG_arg_fail(1)) SWIG_fail;
39157 {
39158 PyThreadState* __tstate = wxPyBeginAllowThreads();
39159 result = (bool)(arg1)->IsSpacer();
39160
39161 wxPyEndAllowThreads(__tstate);
39162 if (PyErr_Occurred()) SWIG_fail;
39163 }
39164 {
39165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39166 }
39167 return resultobj;
39168 fail:
39169 return NULL;
39170 }
39171
39172
39173 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj;
39175 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39176 int arg2 ;
39177 PyObject * obj0 = 0 ;
39178 PyObject * obj1 = 0 ;
39179 char *kwnames[] = {
39180 (char *) "self",(char *) "proportion", NULL
39181 };
39182
39183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39185 if (SWIG_arg_fail(1)) SWIG_fail;
39186 {
39187 arg2 = (int)(SWIG_As_int(obj1));
39188 if (SWIG_arg_fail(2)) SWIG_fail;
39189 }
39190 {
39191 PyThreadState* __tstate = wxPyBeginAllowThreads();
39192 (arg1)->SetProportion(arg2);
39193
39194 wxPyEndAllowThreads(__tstate);
39195 if (PyErr_Occurred()) SWIG_fail;
39196 }
39197 Py_INCREF(Py_None); resultobj = Py_None;
39198 return resultobj;
39199 fail:
39200 return NULL;
39201 }
39202
39203
39204 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39205 PyObject *resultobj;
39206 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39207 int result;
39208 PyObject * obj0 = 0 ;
39209 char *kwnames[] = {
39210 (char *) "self", NULL
39211 };
39212
39213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39215 if (SWIG_arg_fail(1)) SWIG_fail;
39216 {
39217 PyThreadState* __tstate = wxPyBeginAllowThreads();
39218 result = (int)(arg1)->GetProportion();
39219
39220 wxPyEndAllowThreads(__tstate);
39221 if (PyErr_Occurred()) SWIG_fail;
39222 }
39223 {
39224 resultobj = SWIG_From_int((int)(result));
39225 }
39226 return resultobj;
39227 fail:
39228 return NULL;
39229 }
39230
39231
39232 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39233 PyObject *resultobj;
39234 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39235 int arg2 ;
39236 PyObject * obj0 = 0 ;
39237 PyObject * obj1 = 0 ;
39238 char *kwnames[] = {
39239 (char *) "self",(char *) "flag", NULL
39240 };
39241
39242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39244 if (SWIG_arg_fail(1)) SWIG_fail;
39245 {
39246 arg2 = (int)(SWIG_As_int(obj1));
39247 if (SWIG_arg_fail(2)) SWIG_fail;
39248 }
39249 {
39250 PyThreadState* __tstate = wxPyBeginAllowThreads();
39251 (arg1)->SetFlag(arg2);
39252
39253 wxPyEndAllowThreads(__tstate);
39254 if (PyErr_Occurred()) SWIG_fail;
39255 }
39256 Py_INCREF(Py_None); resultobj = Py_None;
39257 return resultobj;
39258 fail:
39259 return NULL;
39260 }
39261
39262
39263 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39264 PyObject *resultobj;
39265 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39266 int result;
39267 PyObject * obj0 = 0 ;
39268 char *kwnames[] = {
39269 (char *) "self", NULL
39270 };
39271
39272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39274 if (SWIG_arg_fail(1)) SWIG_fail;
39275 {
39276 PyThreadState* __tstate = wxPyBeginAllowThreads();
39277 result = (int)(arg1)->GetFlag();
39278
39279 wxPyEndAllowThreads(__tstate);
39280 if (PyErr_Occurred()) SWIG_fail;
39281 }
39282 {
39283 resultobj = SWIG_From_int((int)(result));
39284 }
39285 return resultobj;
39286 fail:
39287 return NULL;
39288 }
39289
39290
39291 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39292 PyObject *resultobj;
39293 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39294 int arg2 ;
39295 PyObject * obj0 = 0 ;
39296 PyObject * obj1 = 0 ;
39297 char *kwnames[] = {
39298 (char *) "self",(char *) "border", NULL
39299 };
39300
39301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39303 if (SWIG_arg_fail(1)) SWIG_fail;
39304 {
39305 arg2 = (int)(SWIG_As_int(obj1));
39306 if (SWIG_arg_fail(2)) SWIG_fail;
39307 }
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 (arg1)->SetBorder(arg2);
39311
39312 wxPyEndAllowThreads(__tstate);
39313 if (PyErr_Occurred()) SWIG_fail;
39314 }
39315 Py_INCREF(Py_None); resultobj = Py_None;
39316 return resultobj;
39317 fail:
39318 return NULL;
39319 }
39320
39321
39322 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39323 PyObject *resultobj;
39324 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39325 int result;
39326 PyObject * obj0 = 0 ;
39327 char *kwnames[] = {
39328 (char *) "self", NULL
39329 };
39330
39331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39333 if (SWIG_arg_fail(1)) SWIG_fail;
39334 {
39335 PyThreadState* __tstate = wxPyBeginAllowThreads();
39336 result = (int)(arg1)->GetBorder();
39337
39338 wxPyEndAllowThreads(__tstate);
39339 if (PyErr_Occurred()) SWIG_fail;
39340 }
39341 {
39342 resultobj = SWIG_From_int((int)(result));
39343 }
39344 return resultobj;
39345 fail:
39346 return NULL;
39347 }
39348
39349
39350 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39351 PyObject *resultobj;
39352 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39353 wxWindow *result;
39354 PyObject * obj0 = 0 ;
39355 char *kwnames[] = {
39356 (char *) "self", NULL
39357 };
39358
39359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39361 if (SWIG_arg_fail(1)) SWIG_fail;
39362 {
39363 PyThreadState* __tstate = wxPyBeginAllowThreads();
39364 result = (wxWindow *)(arg1)->GetWindow();
39365
39366 wxPyEndAllowThreads(__tstate);
39367 if (PyErr_Occurred()) SWIG_fail;
39368 }
39369 {
39370 resultobj = wxPyMake_wxObject(result, 0);
39371 }
39372 return resultobj;
39373 fail:
39374 return NULL;
39375 }
39376
39377
39378 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39379 PyObject *resultobj;
39380 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39381 wxWindow *arg2 = (wxWindow *) 0 ;
39382 PyObject * obj0 = 0 ;
39383 PyObject * obj1 = 0 ;
39384 char *kwnames[] = {
39385 (char *) "self",(char *) "window", NULL
39386 };
39387
39388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39390 if (SWIG_arg_fail(1)) SWIG_fail;
39391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39392 if (SWIG_arg_fail(2)) SWIG_fail;
39393 {
39394 PyThreadState* __tstate = wxPyBeginAllowThreads();
39395 (arg1)->SetWindow(arg2);
39396
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 Py_INCREF(Py_None); resultobj = Py_None;
39401 return resultobj;
39402 fail:
39403 return NULL;
39404 }
39405
39406
39407 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39408 PyObject *resultobj;
39409 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39410 wxSizer *result;
39411 PyObject * obj0 = 0 ;
39412 char *kwnames[] = {
39413 (char *) "self", NULL
39414 };
39415
39416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39418 if (SWIG_arg_fail(1)) SWIG_fail;
39419 {
39420 PyThreadState* __tstate = wxPyBeginAllowThreads();
39421 result = (wxSizer *)(arg1)->GetSizer();
39422
39423 wxPyEndAllowThreads(__tstate);
39424 if (PyErr_Occurred()) SWIG_fail;
39425 }
39426 {
39427 resultobj = wxPyMake_wxObject(result, 0);
39428 }
39429 return resultobj;
39430 fail:
39431 return NULL;
39432 }
39433
39434
39435 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39436 PyObject *resultobj;
39437 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39438 wxSizer *arg2 = (wxSizer *) 0 ;
39439 PyObject * obj0 = 0 ;
39440 PyObject * obj1 = 0 ;
39441 char *kwnames[] = {
39442 (char *) "self",(char *) "sizer", NULL
39443 };
39444
39445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39447 if (SWIG_arg_fail(1)) SWIG_fail;
39448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39449 if (SWIG_arg_fail(2)) SWIG_fail;
39450 {
39451 PyThreadState* __tstate = wxPyBeginAllowThreads();
39452 (arg1)->SetSizer(arg2);
39453
39454 wxPyEndAllowThreads(__tstate);
39455 if (PyErr_Occurred()) SWIG_fail;
39456 }
39457 Py_INCREF(Py_None); resultobj = Py_None;
39458 return resultobj;
39459 fail:
39460 return NULL;
39461 }
39462
39463
39464 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39465 PyObject *resultobj;
39466 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39467 wxSize *result;
39468 PyObject * obj0 = 0 ;
39469 char *kwnames[] = {
39470 (char *) "self", NULL
39471 };
39472
39473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39475 if (SWIG_arg_fail(1)) SWIG_fail;
39476 {
39477 PyThreadState* __tstate = wxPyBeginAllowThreads();
39478 {
39479 wxSize const &_result_ref = (arg1)->GetSpacer();
39480 result = (wxSize *) &_result_ref;
39481 }
39482
39483 wxPyEndAllowThreads(__tstate);
39484 if (PyErr_Occurred()) SWIG_fail;
39485 }
39486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39487 return resultobj;
39488 fail:
39489 return NULL;
39490 }
39491
39492
39493 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39494 PyObject *resultobj;
39495 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39496 wxSize *arg2 = 0 ;
39497 wxSize temp2 ;
39498 PyObject * obj0 = 0 ;
39499 PyObject * obj1 = 0 ;
39500 char *kwnames[] = {
39501 (char *) "self",(char *) "size", NULL
39502 };
39503
39504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39506 if (SWIG_arg_fail(1)) SWIG_fail;
39507 {
39508 arg2 = &temp2;
39509 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39510 }
39511 {
39512 PyThreadState* __tstate = wxPyBeginAllowThreads();
39513 (arg1)->SetSpacer((wxSize const &)*arg2);
39514
39515 wxPyEndAllowThreads(__tstate);
39516 if (PyErr_Occurred()) SWIG_fail;
39517 }
39518 Py_INCREF(Py_None); resultobj = Py_None;
39519 return resultobj;
39520 fail:
39521 return NULL;
39522 }
39523
39524
39525 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39526 PyObject *resultobj;
39527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39528 bool arg2 ;
39529 PyObject * obj0 = 0 ;
39530 PyObject * obj1 = 0 ;
39531 char *kwnames[] = {
39532 (char *) "self",(char *) "show", NULL
39533 };
39534
39535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39537 if (SWIG_arg_fail(1)) SWIG_fail;
39538 {
39539 arg2 = (bool)(SWIG_As_bool(obj1));
39540 if (SWIG_arg_fail(2)) SWIG_fail;
39541 }
39542 {
39543 PyThreadState* __tstate = wxPyBeginAllowThreads();
39544 (arg1)->Show(arg2);
39545
39546 wxPyEndAllowThreads(__tstate);
39547 if (PyErr_Occurred()) SWIG_fail;
39548 }
39549 Py_INCREF(Py_None); resultobj = Py_None;
39550 return resultobj;
39551 fail:
39552 return NULL;
39553 }
39554
39555
39556 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39557 PyObject *resultobj;
39558 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39559 bool result;
39560 PyObject * obj0 = 0 ;
39561 char *kwnames[] = {
39562 (char *) "self", NULL
39563 };
39564
39565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39567 if (SWIG_arg_fail(1)) SWIG_fail;
39568 {
39569 PyThreadState* __tstate = wxPyBeginAllowThreads();
39570 result = (bool)(arg1)->IsShown();
39571
39572 wxPyEndAllowThreads(__tstate);
39573 if (PyErr_Occurred()) SWIG_fail;
39574 }
39575 {
39576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39577 }
39578 return resultobj;
39579 fail:
39580 return NULL;
39581 }
39582
39583
39584 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39585 PyObject *resultobj;
39586 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39587 wxPoint result;
39588 PyObject * obj0 = 0 ;
39589 char *kwnames[] = {
39590 (char *) "self", NULL
39591 };
39592
39593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39595 if (SWIG_arg_fail(1)) SWIG_fail;
39596 {
39597 PyThreadState* __tstate = wxPyBeginAllowThreads();
39598 result = (arg1)->GetPosition();
39599
39600 wxPyEndAllowThreads(__tstate);
39601 if (PyErr_Occurred()) SWIG_fail;
39602 }
39603 {
39604 wxPoint * resultptr;
39605 resultptr = new wxPoint((wxPoint &)(result));
39606 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39607 }
39608 return resultobj;
39609 fail:
39610 return NULL;
39611 }
39612
39613
39614 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39615 PyObject *resultobj;
39616 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39617 PyObject *result;
39618 PyObject * obj0 = 0 ;
39619 char *kwnames[] = {
39620 (char *) "self", NULL
39621 };
39622
39623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39625 if (SWIG_arg_fail(1)) SWIG_fail;
39626 {
39627 PyThreadState* __tstate = wxPyBeginAllowThreads();
39628 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39629
39630 wxPyEndAllowThreads(__tstate);
39631 if (PyErr_Occurred()) SWIG_fail;
39632 }
39633 resultobj = result;
39634 return resultobj;
39635 fail:
39636 return NULL;
39637 }
39638
39639
39640 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39641 PyObject *obj;
39642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39643 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39644 Py_INCREF(obj);
39645 return Py_BuildValue((char *)"");
39646 }
39647 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39648 PyObject *resultobj;
39649 wxSizer *arg1 = (wxSizer *) 0 ;
39650 PyObject *arg2 = (PyObject *) 0 ;
39651 PyObject * obj0 = 0 ;
39652 PyObject * obj1 = 0 ;
39653 char *kwnames[] = {
39654 (char *) "self",(char *) "_self", NULL
39655 };
39656
39657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39659 if (SWIG_arg_fail(1)) SWIG_fail;
39660 arg2 = obj1;
39661 {
39662 PyThreadState* __tstate = wxPyBeginAllowThreads();
39663 wxSizer__setOORInfo(arg1,arg2);
39664
39665 wxPyEndAllowThreads(__tstate);
39666 if (PyErr_Occurred()) SWIG_fail;
39667 }
39668 Py_INCREF(Py_None); resultobj = Py_None;
39669 return resultobj;
39670 fail:
39671 return NULL;
39672 }
39673
39674
39675 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39676 PyObject *resultobj;
39677 wxSizer *arg1 = (wxSizer *) 0 ;
39678 PyObject *arg2 = (PyObject *) 0 ;
39679 int arg3 = (int) 0 ;
39680 int arg4 = (int) 0 ;
39681 int arg5 = (int) 0 ;
39682 PyObject *arg6 = (PyObject *) NULL ;
39683 wxSizerItem *result;
39684 PyObject * obj0 = 0 ;
39685 PyObject * obj1 = 0 ;
39686 PyObject * obj2 = 0 ;
39687 PyObject * obj3 = 0 ;
39688 PyObject * obj4 = 0 ;
39689 PyObject * obj5 = 0 ;
39690 char *kwnames[] = {
39691 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39692 };
39693
39694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39696 if (SWIG_arg_fail(1)) SWIG_fail;
39697 arg2 = obj1;
39698 if (obj2) {
39699 {
39700 arg3 = (int)(SWIG_As_int(obj2));
39701 if (SWIG_arg_fail(3)) SWIG_fail;
39702 }
39703 }
39704 if (obj3) {
39705 {
39706 arg4 = (int)(SWIG_As_int(obj3));
39707 if (SWIG_arg_fail(4)) SWIG_fail;
39708 }
39709 }
39710 if (obj4) {
39711 {
39712 arg5 = (int)(SWIG_As_int(obj4));
39713 if (SWIG_arg_fail(5)) SWIG_fail;
39714 }
39715 }
39716 if (obj5) {
39717 arg6 = obj5;
39718 }
39719 {
39720 PyThreadState* __tstate = wxPyBeginAllowThreads();
39721 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39722
39723 wxPyEndAllowThreads(__tstate);
39724 if (PyErr_Occurred()) SWIG_fail;
39725 }
39726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39727 return resultobj;
39728 fail:
39729 return NULL;
39730 }
39731
39732
39733 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39734 PyObject *resultobj;
39735 wxSizer *arg1 = (wxSizer *) 0 ;
39736 int arg2 ;
39737 PyObject *arg3 = (PyObject *) 0 ;
39738 int arg4 = (int) 0 ;
39739 int arg5 = (int) 0 ;
39740 int arg6 = (int) 0 ;
39741 PyObject *arg7 = (PyObject *) NULL ;
39742 wxSizerItem *result;
39743 PyObject * obj0 = 0 ;
39744 PyObject * obj1 = 0 ;
39745 PyObject * obj2 = 0 ;
39746 PyObject * obj3 = 0 ;
39747 PyObject * obj4 = 0 ;
39748 PyObject * obj5 = 0 ;
39749 PyObject * obj6 = 0 ;
39750 char *kwnames[] = {
39751 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39752 };
39753
39754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39756 if (SWIG_arg_fail(1)) SWIG_fail;
39757 {
39758 arg2 = (int)(SWIG_As_int(obj1));
39759 if (SWIG_arg_fail(2)) SWIG_fail;
39760 }
39761 arg3 = obj2;
39762 if (obj3) {
39763 {
39764 arg4 = (int)(SWIG_As_int(obj3));
39765 if (SWIG_arg_fail(4)) SWIG_fail;
39766 }
39767 }
39768 if (obj4) {
39769 {
39770 arg5 = (int)(SWIG_As_int(obj4));
39771 if (SWIG_arg_fail(5)) SWIG_fail;
39772 }
39773 }
39774 if (obj5) {
39775 {
39776 arg6 = (int)(SWIG_As_int(obj5));
39777 if (SWIG_arg_fail(6)) SWIG_fail;
39778 }
39779 }
39780 if (obj6) {
39781 arg7 = obj6;
39782 }
39783 {
39784 PyThreadState* __tstate = wxPyBeginAllowThreads();
39785 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39786
39787 wxPyEndAllowThreads(__tstate);
39788 if (PyErr_Occurred()) SWIG_fail;
39789 }
39790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39791 return resultobj;
39792 fail:
39793 return NULL;
39794 }
39795
39796
39797 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39798 PyObject *resultobj;
39799 wxSizer *arg1 = (wxSizer *) 0 ;
39800 PyObject *arg2 = (PyObject *) 0 ;
39801 int arg3 = (int) 0 ;
39802 int arg4 = (int) 0 ;
39803 int arg5 = (int) 0 ;
39804 PyObject *arg6 = (PyObject *) NULL ;
39805 wxSizerItem *result;
39806 PyObject * obj0 = 0 ;
39807 PyObject * obj1 = 0 ;
39808 PyObject * obj2 = 0 ;
39809 PyObject * obj3 = 0 ;
39810 PyObject * obj4 = 0 ;
39811 PyObject * obj5 = 0 ;
39812 char *kwnames[] = {
39813 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39814 };
39815
39816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39818 if (SWIG_arg_fail(1)) SWIG_fail;
39819 arg2 = obj1;
39820 if (obj2) {
39821 {
39822 arg3 = (int)(SWIG_As_int(obj2));
39823 if (SWIG_arg_fail(3)) SWIG_fail;
39824 }
39825 }
39826 if (obj3) {
39827 {
39828 arg4 = (int)(SWIG_As_int(obj3));
39829 if (SWIG_arg_fail(4)) SWIG_fail;
39830 }
39831 }
39832 if (obj4) {
39833 {
39834 arg5 = (int)(SWIG_As_int(obj4));
39835 if (SWIG_arg_fail(5)) SWIG_fail;
39836 }
39837 }
39838 if (obj5) {
39839 arg6 = obj5;
39840 }
39841 {
39842 PyThreadState* __tstate = wxPyBeginAllowThreads();
39843 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39844
39845 wxPyEndAllowThreads(__tstate);
39846 if (PyErr_Occurred()) SWIG_fail;
39847 }
39848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39849 return resultobj;
39850 fail:
39851 return NULL;
39852 }
39853
39854
39855 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39856 PyObject *resultobj;
39857 wxSizer *arg1 = (wxSizer *) 0 ;
39858 PyObject *arg2 = (PyObject *) 0 ;
39859 bool result;
39860 PyObject * obj0 = 0 ;
39861 PyObject * obj1 = 0 ;
39862 char *kwnames[] = {
39863 (char *) "self",(char *) "item", NULL
39864 };
39865
39866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39868 if (SWIG_arg_fail(1)) SWIG_fail;
39869 arg2 = obj1;
39870 {
39871 PyThreadState* __tstate = wxPyBeginAllowThreads();
39872 result = (bool)wxSizer_Remove(arg1,arg2);
39873
39874 wxPyEndAllowThreads(__tstate);
39875 if (PyErr_Occurred()) SWIG_fail;
39876 }
39877 {
39878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39879 }
39880 return resultobj;
39881 fail:
39882 return NULL;
39883 }
39884
39885
39886 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39887 PyObject *resultobj;
39888 wxSizer *arg1 = (wxSizer *) 0 ;
39889 PyObject *arg2 = (PyObject *) 0 ;
39890 bool result;
39891 PyObject * obj0 = 0 ;
39892 PyObject * obj1 = 0 ;
39893 char *kwnames[] = {
39894 (char *) "self",(char *) "item", NULL
39895 };
39896
39897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39899 if (SWIG_arg_fail(1)) SWIG_fail;
39900 arg2 = obj1;
39901 {
39902 PyThreadState* __tstate = wxPyBeginAllowThreads();
39903 result = (bool)wxSizer_Detach(arg1,arg2);
39904
39905 wxPyEndAllowThreads(__tstate);
39906 if (PyErr_Occurred()) SWIG_fail;
39907 }
39908 {
39909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39910 }
39911 return resultobj;
39912 fail:
39913 return NULL;
39914 }
39915
39916
39917 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39918 PyObject *resultobj;
39919 wxSizer *arg1 = (wxSizer *) 0 ;
39920 PyObject *arg2 = (PyObject *) 0 ;
39921 wxSizerItem *result;
39922 PyObject * obj0 = 0 ;
39923 PyObject * obj1 = 0 ;
39924 char *kwnames[] = {
39925 (char *) "self",(char *) "item", NULL
39926 };
39927
39928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39930 if (SWIG_arg_fail(1)) SWIG_fail;
39931 arg2 = obj1;
39932 {
39933 PyThreadState* __tstate = wxPyBeginAllowThreads();
39934 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39935
39936 wxPyEndAllowThreads(__tstate);
39937 if (PyErr_Occurred()) SWIG_fail;
39938 }
39939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj;
39948 wxSizer *arg1 = (wxSizer *) 0 ;
39949 PyObject *arg2 = (PyObject *) 0 ;
39950 wxSize *arg3 = 0 ;
39951 wxSize temp3 ;
39952 PyObject * obj0 = 0 ;
39953 PyObject * obj1 = 0 ;
39954 PyObject * obj2 = 0 ;
39955 char *kwnames[] = {
39956 (char *) "self",(char *) "item",(char *) "size", NULL
39957 };
39958
39959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39961 if (SWIG_arg_fail(1)) SWIG_fail;
39962 arg2 = obj1;
39963 {
39964 arg3 = &temp3;
39965 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39966 }
39967 {
39968 PyThreadState* __tstate = wxPyBeginAllowThreads();
39969 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39970
39971 wxPyEndAllowThreads(__tstate);
39972 if (PyErr_Occurred()) SWIG_fail;
39973 }
39974 Py_INCREF(Py_None); resultobj = Py_None;
39975 return resultobj;
39976 fail:
39977 return NULL;
39978 }
39979
39980
39981 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39982 PyObject *resultobj;
39983 wxSizer *arg1 = (wxSizer *) 0 ;
39984 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39985 wxSizerItem *result;
39986 PyObject * obj0 = 0 ;
39987 PyObject * obj1 = 0 ;
39988 char *kwnames[] = {
39989 (char *) "self",(char *) "item", NULL
39990 };
39991
39992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39994 if (SWIG_arg_fail(1)) SWIG_fail;
39995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39996 if (SWIG_arg_fail(2)) SWIG_fail;
39997 {
39998 PyThreadState* __tstate = wxPyBeginAllowThreads();
39999 result = (wxSizerItem *)(arg1)->Add(arg2);
40000
40001 wxPyEndAllowThreads(__tstate);
40002 if (PyErr_Occurred()) SWIG_fail;
40003 }
40004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40005 return resultobj;
40006 fail:
40007 return NULL;
40008 }
40009
40010
40011 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40012 PyObject *resultobj;
40013 wxSizer *arg1 = (wxSizer *) 0 ;
40014 size_t arg2 ;
40015 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40016 wxSizerItem *result;
40017 PyObject * obj0 = 0 ;
40018 PyObject * obj1 = 0 ;
40019 PyObject * obj2 = 0 ;
40020 char *kwnames[] = {
40021 (char *) "self",(char *) "index",(char *) "item", NULL
40022 };
40023
40024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40026 if (SWIG_arg_fail(1)) SWIG_fail;
40027 {
40028 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40029 if (SWIG_arg_fail(2)) SWIG_fail;
40030 }
40031 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40032 if (SWIG_arg_fail(3)) SWIG_fail;
40033 {
40034 PyThreadState* __tstate = wxPyBeginAllowThreads();
40035 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40036
40037 wxPyEndAllowThreads(__tstate);
40038 if (PyErr_Occurred()) SWIG_fail;
40039 }
40040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40041 return resultobj;
40042 fail:
40043 return NULL;
40044 }
40045
40046
40047 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40048 PyObject *resultobj;
40049 wxSizer *arg1 = (wxSizer *) 0 ;
40050 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40051 wxSizerItem *result;
40052 PyObject * obj0 = 0 ;
40053 PyObject * obj1 = 0 ;
40054 char *kwnames[] = {
40055 (char *) "self",(char *) "item", NULL
40056 };
40057
40058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40060 if (SWIG_arg_fail(1)) SWIG_fail;
40061 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40062 if (SWIG_arg_fail(2)) SWIG_fail;
40063 {
40064 PyThreadState* __tstate = wxPyBeginAllowThreads();
40065 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40066
40067 wxPyEndAllowThreads(__tstate);
40068 if (PyErr_Occurred()) SWIG_fail;
40069 }
40070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40071 return resultobj;
40072 fail:
40073 return NULL;
40074 }
40075
40076
40077 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40078 PyObject *resultobj;
40079 wxSizer *arg1 = (wxSizer *) 0 ;
40080 int arg2 ;
40081 int arg3 ;
40082 int arg4 ;
40083 int arg5 ;
40084 PyObject * obj0 = 0 ;
40085 PyObject * obj1 = 0 ;
40086 PyObject * obj2 = 0 ;
40087 PyObject * obj3 = 0 ;
40088 PyObject * obj4 = 0 ;
40089 char *kwnames[] = {
40090 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40091 };
40092
40093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40095 if (SWIG_arg_fail(1)) SWIG_fail;
40096 {
40097 arg2 = (int)(SWIG_As_int(obj1));
40098 if (SWIG_arg_fail(2)) SWIG_fail;
40099 }
40100 {
40101 arg3 = (int)(SWIG_As_int(obj2));
40102 if (SWIG_arg_fail(3)) SWIG_fail;
40103 }
40104 {
40105 arg4 = (int)(SWIG_As_int(obj3));
40106 if (SWIG_arg_fail(4)) SWIG_fail;
40107 }
40108 {
40109 arg5 = (int)(SWIG_As_int(obj4));
40110 if (SWIG_arg_fail(5)) SWIG_fail;
40111 }
40112 {
40113 PyThreadState* __tstate = wxPyBeginAllowThreads();
40114 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40115
40116 wxPyEndAllowThreads(__tstate);
40117 if (PyErr_Occurred()) SWIG_fail;
40118 }
40119 Py_INCREF(Py_None); resultobj = Py_None;
40120 return resultobj;
40121 fail:
40122 return NULL;
40123 }
40124
40125
40126 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40127 PyObject *resultobj;
40128 wxSizer *arg1 = (wxSizer *) 0 ;
40129 wxSize *arg2 = 0 ;
40130 wxSize temp2 ;
40131 PyObject * obj0 = 0 ;
40132 PyObject * obj1 = 0 ;
40133 char *kwnames[] = {
40134 (char *) "self",(char *) "size", NULL
40135 };
40136
40137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40139 if (SWIG_arg_fail(1)) SWIG_fail;
40140 {
40141 arg2 = &temp2;
40142 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40143 }
40144 {
40145 PyThreadState* __tstate = wxPyBeginAllowThreads();
40146 (arg1)->SetMinSize((wxSize const &)*arg2);
40147
40148 wxPyEndAllowThreads(__tstate);
40149 if (PyErr_Occurred()) SWIG_fail;
40150 }
40151 Py_INCREF(Py_None); resultobj = Py_None;
40152 return resultobj;
40153 fail:
40154 return NULL;
40155 }
40156
40157
40158 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40159 PyObject *resultobj;
40160 wxSizer *arg1 = (wxSizer *) 0 ;
40161 wxSize result;
40162 PyObject * obj0 = 0 ;
40163 char *kwnames[] = {
40164 (char *) "self", NULL
40165 };
40166
40167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40169 if (SWIG_arg_fail(1)) SWIG_fail;
40170 {
40171 PyThreadState* __tstate = wxPyBeginAllowThreads();
40172 result = (arg1)->GetSize();
40173
40174 wxPyEndAllowThreads(__tstate);
40175 if (PyErr_Occurred()) SWIG_fail;
40176 }
40177 {
40178 wxSize * resultptr;
40179 resultptr = new wxSize((wxSize &)(result));
40180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40181 }
40182 return resultobj;
40183 fail:
40184 return NULL;
40185 }
40186
40187
40188 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40189 PyObject *resultobj;
40190 wxSizer *arg1 = (wxSizer *) 0 ;
40191 wxPoint result;
40192 PyObject * obj0 = 0 ;
40193 char *kwnames[] = {
40194 (char *) "self", NULL
40195 };
40196
40197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40199 if (SWIG_arg_fail(1)) SWIG_fail;
40200 {
40201 PyThreadState* __tstate = wxPyBeginAllowThreads();
40202 result = (arg1)->GetPosition();
40203
40204 wxPyEndAllowThreads(__tstate);
40205 if (PyErr_Occurred()) SWIG_fail;
40206 }
40207 {
40208 wxPoint * resultptr;
40209 resultptr = new wxPoint((wxPoint &)(result));
40210 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40211 }
40212 return resultobj;
40213 fail:
40214 return NULL;
40215 }
40216
40217
40218 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40219 PyObject *resultobj;
40220 wxSizer *arg1 = (wxSizer *) 0 ;
40221 wxSize result;
40222 PyObject * obj0 = 0 ;
40223 char *kwnames[] = {
40224 (char *) "self", NULL
40225 };
40226
40227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40229 if (SWIG_arg_fail(1)) SWIG_fail;
40230 {
40231 PyThreadState* __tstate = wxPyBeginAllowThreads();
40232 result = (arg1)->GetMinSize();
40233
40234 wxPyEndAllowThreads(__tstate);
40235 if (PyErr_Occurred()) SWIG_fail;
40236 }
40237 {
40238 wxSize * resultptr;
40239 resultptr = new wxSize((wxSize &)(result));
40240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40241 }
40242 return resultobj;
40243 fail:
40244 return NULL;
40245 }
40246
40247
40248 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40249 PyObject *resultobj;
40250 wxSizer *arg1 = (wxSizer *) 0 ;
40251 PyObject * obj0 = 0 ;
40252 char *kwnames[] = {
40253 (char *) "self", NULL
40254 };
40255
40256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40258 if (SWIG_arg_fail(1)) SWIG_fail;
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 (arg1)->RecalcSizes();
40262
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 Py_INCREF(Py_None); resultobj = Py_None;
40267 return resultobj;
40268 fail:
40269 return NULL;
40270 }
40271
40272
40273 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40274 PyObject *resultobj;
40275 wxSizer *arg1 = (wxSizer *) 0 ;
40276 wxSize result;
40277 PyObject * obj0 = 0 ;
40278 char *kwnames[] = {
40279 (char *) "self", NULL
40280 };
40281
40282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40284 if (SWIG_arg_fail(1)) SWIG_fail;
40285 {
40286 PyThreadState* __tstate = wxPyBeginAllowThreads();
40287 result = (arg1)->CalcMin();
40288
40289 wxPyEndAllowThreads(__tstate);
40290 if (PyErr_Occurred()) SWIG_fail;
40291 }
40292 {
40293 wxSize * resultptr;
40294 resultptr = new wxSize((wxSize &)(result));
40295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40296 }
40297 return resultobj;
40298 fail:
40299 return NULL;
40300 }
40301
40302
40303 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40304 PyObject *resultobj;
40305 wxSizer *arg1 = (wxSizer *) 0 ;
40306 PyObject * obj0 = 0 ;
40307 char *kwnames[] = {
40308 (char *) "self", NULL
40309 };
40310
40311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40313 if (SWIG_arg_fail(1)) SWIG_fail;
40314 {
40315 PyThreadState* __tstate = wxPyBeginAllowThreads();
40316 (arg1)->Layout();
40317
40318 wxPyEndAllowThreads(__tstate);
40319 if (PyErr_Occurred()) SWIG_fail;
40320 }
40321 Py_INCREF(Py_None); resultobj = Py_None;
40322 return resultobj;
40323 fail:
40324 return NULL;
40325 }
40326
40327
40328 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40329 PyObject *resultobj;
40330 wxSizer *arg1 = (wxSizer *) 0 ;
40331 wxWindow *arg2 = (wxWindow *) 0 ;
40332 wxSize result;
40333 PyObject * obj0 = 0 ;
40334 PyObject * obj1 = 0 ;
40335 char *kwnames[] = {
40336 (char *) "self",(char *) "window", NULL
40337 };
40338
40339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40341 if (SWIG_arg_fail(1)) SWIG_fail;
40342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40343 if (SWIG_arg_fail(2)) SWIG_fail;
40344 {
40345 PyThreadState* __tstate = wxPyBeginAllowThreads();
40346 result = (arg1)->Fit(arg2);
40347
40348 wxPyEndAllowThreads(__tstate);
40349 if (PyErr_Occurred()) SWIG_fail;
40350 }
40351 {
40352 wxSize * resultptr;
40353 resultptr = new wxSize((wxSize &)(result));
40354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40355 }
40356 return resultobj;
40357 fail:
40358 return NULL;
40359 }
40360
40361
40362 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40363 PyObject *resultobj;
40364 wxSizer *arg1 = (wxSizer *) 0 ;
40365 wxWindow *arg2 = (wxWindow *) 0 ;
40366 PyObject * obj0 = 0 ;
40367 PyObject * obj1 = 0 ;
40368 char *kwnames[] = {
40369 (char *) "self",(char *) "window", NULL
40370 };
40371
40372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40374 if (SWIG_arg_fail(1)) SWIG_fail;
40375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40376 if (SWIG_arg_fail(2)) SWIG_fail;
40377 {
40378 PyThreadState* __tstate = wxPyBeginAllowThreads();
40379 (arg1)->FitInside(arg2);
40380
40381 wxPyEndAllowThreads(__tstate);
40382 if (PyErr_Occurred()) SWIG_fail;
40383 }
40384 Py_INCREF(Py_None); resultobj = Py_None;
40385 return resultobj;
40386 fail:
40387 return NULL;
40388 }
40389
40390
40391 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40392 PyObject *resultobj;
40393 wxSizer *arg1 = (wxSizer *) 0 ;
40394 wxWindow *arg2 = (wxWindow *) 0 ;
40395 PyObject * obj0 = 0 ;
40396 PyObject * obj1 = 0 ;
40397 char *kwnames[] = {
40398 (char *) "self",(char *) "window", NULL
40399 };
40400
40401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40403 if (SWIG_arg_fail(1)) SWIG_fail;
40404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40405 if (SWIG_arg_fail(2)) SWIG_fail;
40406 {
40407 PyThreadState* __tstate = wxPyBeginAllowThreads();
40408 (arg1)->SetSizeHints(arg2);
40409
40410 wxPyEndAllowThreads(__tstate);
40411 if (PyErr_Occurred()) SWIG_fail;
40412 }
40413 Py_INCREF(Py_None); resultobj = Py_None;
40414 return resultobj;
40415 fail:
40416 return NULL;
40417 }
40418
40419
40420 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40421 PyObject *resultobj;
40422 wxSizer *arg1 = (wxSizer *) 0 ;
40423 wxWindow *arg2 = (wxWindow *) 0 ;
40424 PyObject * obj0 = 0 ;
40425 PyObject * obj1 = 0 ;
40426 char *kwnames[] = {
40427 (char *) "self",(char *) "window", NULL
40428 };
40429
40430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40432 if (SWIG_arg_fail(1)) SWIG_fail;
40433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40434 if (SWIG_arg_fail(2)) SWIG_fail;
40435 {
40436 PyThreadState* __tstate = wxPyBeginAllowThreads();
40437 (arg1)->SetVirtualSizeHints(arg2);
40438
40439 wxPyEndAllowThreads(__tstate);
40440 if (PyErr_Occurred()) SWIG_fail;
40441 }
40442 Py_INCREF(Py_None); resultobj = Py_None;
40443 return resultobj;
40444 fail:
40445 return NULL;
40446 }
40447
40448
40449 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40450 PyObject *resultobj;
40451 wxSizer *arg1 = (wxSizer *) 0 ;
40452 bool arg2 = (bool) false ;
40453 PyObject * obj0 = 0 ;
40454 PyObject * obj1 = 0 ;
40455 char *kwnames[] = {
40456 (char *) "self",(char *) "deleteWindows", NULL
40457 };
40458
40459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40461 if (SWIG_arg_fail(1)) SWIG_fail;
40462 if (obj1) {
40463 {
40464 arg2 = (bool)(SWIG_As_bool(obj1));
40465 if (SWIG_arg_fail(2)) SWIG_fail;
40466 }
40467 }
40468 {
40469 PyThreadState* __tstate = wxPyBeginAllowThreads();
40470 (arg1)->Clear(arg2);
40471
40472 wxPyEndAllowThreads(__tstate);
40473 if (PyErr_Occurred()) SWIG_fail;
40474 }
40475 Py_INCREF(Py_None); resultobj = Py_None;
40476 return resultobj;
40477 fail:
40478 return NULL;
40479 }
40480
40481
40482 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40483 PyObject *resultobj;
40484 wxSizer *arg1 = (wxSizer *) 0 ;
40485 PyObject * obj0 = 0 ;
40486 char *kwnames[] = {
40487 (char *) "self", NULL
40488 };
40489
40490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40492 if (SWIG_arg_fail(1)) SWIG_fail;
40493 {
40494 PyThreadState* __tstate = wxPyBeginAllowThreads();
40495 (arg1)->DeleteWindows();
40496
40497 wxPyEndAllowThreads(__tstate);
40498 if (PyErr_Occurred()) SWIG_fail;
40499 }
40500 Py_INCREF(Py_None); resultobj = Py_None;
40501 return resultobj;
40502 fail:
40503 return NULL;
40504 }
40505
40506
40507 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40508 PyObject *resultobj;
40509 wxSizer *arg1 = (wxSizer *) 0 ;
40510 PyObject *result;
40511 PyObject * obj0 = 0 ;
40512 char *kwnames[] = {
40513 (char *) "self", NULL
40514 };
40515
40516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40518 if (SWIG_arg_fail(1)) SWIG_fail;
40519 {
40520 PyThreadState* __tstate = wxPyBeginAllowThreads();
40521 result = (PyObject *)wxSizer_GetChildren(arg1);
40522
40523 wxPyEndAllowThreads(__tstate);
40524 if (PyErr_Occurred()) SWIG_fail;
40525 }
40526 resultobj = result;
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40534 PyObject *resultobj;
40535 wxSizer *arg1 = (wxSizer *) 0 ;
40536 PyObject *arg2 = (PyObject *) 0 ;
40537 bool arg3 = (bool) true ;
40538 bool arg4 = (bool) false ;
40539 bool result;
40540 PyObject * obj0 = 0 ;
40541 PyObject * obj1 = 0 ;
40542 PyObject * obj2 = 0 ;
40543 PyObject * obj3 = 0 ;
40544 char *kwnames[] = {
40545 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40546 };
40547
40548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40550 if (SWIG_arg_fail(1)) SWIG_fail;
40551 arg2 = obj1;
40552 if (obj2) {
40553 {
40554 arg3 = (bool)(SWIG_As_bool(obj2));
40555 if (SWIG_arg_fail(3)) SWIG_fail;
40556 }
40557 }
40558 if (obj3) {
40559 {
40560 arg4 = (bool)(SWIG_As_bool(obj3));
40561 if (SWIG_arg_fail(4)) SWIG_fail;
40562 }
40563 }
40564 {
40565 PyThreadState* __tstate = wxPyBeginAllowThreads();
40566 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40567
40568 wxPyEndAllowThreads(__tstate);
40569 if (PyErr_Occurred()) SWIG_fail;
40570 }
40571 {
40572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40573 }
40574 return resultobj;
40575 fail:
40576 return NULL;
40577 }
40578
40579
40580 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40581 PyObject *resultobj;
40582 wxSizer *arg1 = (wxSizer *) 0 ;
40583 PyObject *arg2 = (PyObject *) 0 ;
40584 bool result;
40585 PyObject * obj0 = 0 ;
40586 PyObject * obj1 = 0 ;
40587 char *kwnames[] = {
40588 (char *) "self",(char *) "item", NULL
40589 };
40590
40591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40593 if (SWIG_arg_fail(1)) SWIG_fail;
40594 arg2 = obj1;
40595 {
40596 PyThreadState* __tstate = wxPyBeginAllowThreads();
40597 result = (bool)wxSizer_IsShown(arg1,arg2);
40598
40599 wxPyEndAllowThreads(__tstate);
40600 if (PyErr_Occurred()) SWIG_fail;
40601 }
40602 {
40603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40604 }
40605 return resultobj;
40606 fail:
40607 return NULL;
40608 }
40609
40610
40611 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40612 PyObject *resultobj;
40613 wxSizer *arg1 = (wxSizer *) 0 ;
40614 bool arg2 ;
40615 PyObject * obj0 = 0 ;
40616 PyObject * obj1 = 0 ;
40617 char *kwnames[] = {
40618 (char *) "self",(char *) "show", NULL
40619 };
40620
40621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40623 if (SWIG_arg_fail(1)) SWIG_fail;
40624 {
40625 arg2 = (bool)(SWIG_As_bool(obj1));
40626 if (SWIG_arg_fail(2)) SWIG_fail;
40627 }
40628 {
40629 PyThreadState* __tstate = wxPyBeginAllowThreads();
40630 (arg1)->ShowItems(arg2);
40631
40632 wxPyEndAllowThreads(__tstate);
40633 if (PyErr_Occurred()) SWIG_fail;
40634 }
40635 Py_INCREF(Py_None); resultobj = Py_None;
40636 return resultobj;
40637 fail:
40638 return NULL;
40639 }
40640
40641
40642 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40643 PyObject *obj;
40644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40645 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40646 Py_INCREF(obj);
40647 return Py_BuildValue((char *)"");
40648 }
40649 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40650 PyObject *resultobj;
40651 wxPySizer *result;
40652 char *kwnames[] = {
40653 NULL
40654 };
40655
40656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40657 {
40658 PyThreadState* __tstate = wxPyBeginAllowThreads();
40659 result = (wxPySizer *)new wxPySizer();
40660
40661 wxPyEndAllowThreads(__tstate);
40662 if (PyErr_Occurred()) SWIG_fail;
40663 }
40664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40665 return resultobj;
40666 fail:
40667 return NULL;
40668 }
40669
40670
40671 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40672 PyObject *resultobj;
40673 wxPySizer *arg1 = (wxPySizer *) 0 ;
40674 PyObject *arg2 = (PyObject *) 0 ;
40675 PyObject *arg3 = (PyObject *) 0 ;
40676 PyObject * obj0 = 0 ;
40677 PyObject * obj1 = 0 ;
40678 PyObject * obj2 = 0 ;
40679 char *kwnames[] = {
40680 (char *) "self",(char *) "self",(char *) "_class", NULL
40681 };
40682
40683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40685 if (SWIG_arg_fail(1)) SWIG_fail;
40686 arg2 = obj1;
40687 arg3 = obj2;
40688 {
40689 PyThreadState* __tstate = wxPyBeginAllowThreads();
40690 (arg1)->_setCallbackInfo(arg2,arg3);
40691
40692 wxPyEndAllowThreads(__tstate);
40693 if (PyErr_Occurred()) SWIG_fail;
40694 }
40695 Py_INCREF(Py_None); resultobj = Py_None;
40696 return resultobj;
40697 fail:
40698 return NULL;
40699 }
40700
40701
40702 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40703 PyObject *obj;
40704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40705 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40706 Py_INCREF(obj);
40707 return Py_BuildValue((char *)"");
40708 }
40709 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40710 PyObject *resultobj;
40711 int arg1 = (int) wxHORIZONTAL ;
40712 wxBoxSizer *result;
40713 PyObject * obj0 = 0 ;
40714 char *kwnames[] = {
40715 (char *) "orient", NULL
40716 };
40717
40718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40719 if (obj0) {
40720 {
40721 arg1 = (int)(SWIG_As_int(obj0));
40722 if (SWIG_arg_fail(1)) SWIG_fail;
40723 }
40724 }
40725 {
40726 PyThreadState* __tstate = wxPyBeginAllowThreads();
40727 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40728
40729 wxPyEndAllowThreads(__tstate);
40730 if (PyErr_Occurred()) SWIG_fail;
40731 }
40732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40733 return resultobj;
40734 fail:
40735 return NULL;
40736 }
40737
40738
40739 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40740 PyObject *resultobj;
40741 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40742 int result;
40743 PyObject * obj0 = 0 ;
40744 char *kwnames[] = {
40745 (char *) "self", NULL
40746 };
40747
40748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40750 if (SWIG_arg_fail(1)) SWIG_fail;
40751 {
40752 PyThreadState* __tstate = wxPyBeginAllowThreads();
40753 result = (int)(arg1)->GetOrientation();
40754
40755 wxPyEndAllowThreads(__tstate);
40756 if (PyErr_Occurred()) SWIG_fail;
40757 }
40758 {
40759 resultobj = SWIG_From_int((int)(result));
40760 }
40761 return resultobj;
40762 fail:
40763 return NULL;
40764 }
40765
40766
40767 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40768 PyObject *resultobj;
40769 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40770 int arg2 ;
40771 PyObject * obj0 = 0 ;
40772 PyObject * obj1 = 0 ;
40773 char *kwnames[] = {
40774 (char *) "self",(char *) "orient", NULL
40775 };
40776
40777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40779 if (SWIG_arg_fail(1)) SWIG_fail;
40780 {
40781 arg2 = (int)(SWIG_As_int(obj1));
40782 if (SWIG_arg_fail(2)) SWIG_fail;
40783 }
40784 {
40785 PyThreadState* __tstate = wxPyBeginAllowThreads();
40786 (arg1)->SetOrientation(arg2);
40787
40788 wxPyEndAllowThreads(__tstate);
40789 if (PyErr_Occurred()) SWIG_fail;
40790 }
40791 Py_INCREF(Py_None); resultobj = Py_None;
40792 return resultobj;
40793 fail:
40794 return NULL;
40795 }
40796
40797
40798 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40799 PyObject *obj;
40800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40801 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40802 Py_INCREF(obj);
40803 return Py_BuildValue((char *)"");
40804 }
40805 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40806 PyObject *resultobj;
40807 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40808 int arg2 = (int) wxHORIZONTAL ;
40809 wxStaticBoxSizer *result;
40810 PyObject * obj0 = 0 ;
40811 PyObject * obj1 = 0 ;
40812 char *kwnames[] = {
40813 (char *) "box",(char *) "orient", NULL
40814 };
40815
40816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40818 if (SWIG_arg_fail(1)) SWIG_fail;
40819 if (obj1) {
40820 {
40821 arg2 = (int)(SWIG_As_int(obj1));
40822 if (SWIG_arg_fail(2)) SWIG_fail;
40823 }
40824 }
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40828
40829 wxPyEndAllowThreads(__tstate);
40830 if (PyErr_Occurred()) SWIG_fail;
40831 }
40832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40833 return resultobj;
40834 fail:
40835 return NULL;
40836 }
40837
40838
40839 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40840 PyObject *resultobj;
40841 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40842 wxStaticBox *result;
40843 PyObject * obj0 = 0 ;
40844 char *kwnames[] = {
40845 (char *) "self", NULL
40846 };
40847
40848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40850 if (SWIG_arg_fail(1)) SWIG_fail;
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 result = (wxStaticBox *)(arg1)->GetStaticBox();
40854
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 {
40859 resultobj = wxPyMake_wxObject(result, 0);
40860 }
40861 return resultobj;
40862 fail:
40863 return NULL;
40864 }
40865
40866
40867 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40868 PyObject *obj;
40869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40870 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40871 Py_INCREF(obj);
40872 return Py_BuildValue((char *)"");
40873 }
40874 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40875 PyObject *resultobj;
40876 int arg1 = (int) 1 ;
40877 int arg2 = (int) 0 ;
40878 int arg3 = (int) 0 ;
40879 int arg4 = (int) 0 ;
40880 wxGridSizer *result;
40881 PyObject * obj0 = 0 ;
40882 PyObject * obj1 = 0 ;
40883 PyObject * obj2 = 0 ;
40884 PyObject * obj3 = 0 ;
40885 char *kwnames[] = {
40886 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40887 };
40888
40889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40890 if (obj0) {
40891 {
40892 arg1 = (int)(SWIG_As_int(obj0));
40893 if (SWIG_arg_fail(1)) SWIG_fail;
40894 }
40895 }
40896 if (obj1) {
40897 {
40898 arg2 = (int)(SWIG_As_int(obj1));
40899 if (SWIG_arg_fail(2)) SWIG_fail;
40900 }
40901 }
40902 if (obj2) {
40903 {
40904 arg3 = (int)(SWIG_As_int(obj2));
40905 if (SWIG_arg_fail(3)) SWIG_fail;
40906 }
40907 }
40908 if (obj3) {
40909 {
40910 arg4 = (int)(SWIG_As_int(obj3));
40911 if (SWIG_arg_fail(4)) SWIG_fail;
40912 }
40913 }
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40917
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40922 return resultobj;
40923 fail:
40924 return NULL;
40925 }
40926
40927
40928 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40929 PyObject *resultobj;
40930 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40931 int arg2 ;
40932 PyObject * obj0 = 0 ;
40933 PyObject * obj1 = 0 ;
40934 char *kwnames[] = {
40935 (char *) "self",(char *) "cols", NULL
40936 };
40937
40938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40940 if (SWIG_arg_fail(1)) SWIG_fail;
40941 {
40942 arg2 = (int)(SWIG_As_int(obj1));
40943 if (SWIG_arg_fail(2)) SWIG_fail;
40944 }
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 (arg1)->SetCols(arg2);
40948
40949 wxPyEndAllowThreads(__tstate);
40950 if (PyErr_Occurred()) SWIG_fail;
40951 }
40952 Py_INCREF(Py_None); resultobj = Py_None;
40953 return resultobj;
40954 fail:
40955 return NULL;
40956 }
40957
40958
40959 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40960 PyObject *resultobj;
40961 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40962 int arg2 ;
40963 PyObject * obj0 = 0 ;
40964 PyObject * obj1 = 0 ;
40965 char *kwnames[] = {
40966 (char *) "self",(char *) "rows", NULL
40967 };
40968
40969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40971 if (SWIG_arg_fail(1)) SWIG_fail;
40972 {
40973 arg2 = (int)(SWIG_As_int(obj1));
40974 if (SWIG_arg_fail(2)) SWIG_fail;
40975 }
40976 {
40977 PyThreadState* __tstate = wxPyBeginAllowThreads();
40978 (arg1)->SetRows(arg2);
40979
40980 wxPyEndAllowThreads(__tstate);
40981 if (PyErr_Occurred()) SWIG_fail;
40982 }
40983 Py_INCREF(Py_None); resultobj = Py_None;
40984 return resultobj;
40985 fail:
40986 return NULL;
40987 }
40988
40989
40990 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40991 PyObject *resultobj;
40992 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40993 int arg2 ;
40994 PyObject * obj0 = 0 ;
40995 PyObject * obj1 = 0 ;
40996 char *kwnames[] = {
40997 (char *) "self",(char *) "gap", NULL
40998 };
40999
41000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41002 if (SWIG_arg_fail(1)) SWIG_fail;
41003 {
41004 arg2 = (int)(SWIG_As_int(obj1));
41005 if (SWIG_arg_fail(2)) SWIG_fail;
41006 }
41007 {
41008 PyThreadState* __tstate = wxPyBeginAllowThreads();
41009 (arg1)->SetVGap(arg2);
41010
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 Py_INCREF(Py_None); resultobj = Py_None;
41015 return resultobj;
41016 fail:
41017 return NULL;
41018 }
41019
41020
41021 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41022 PyObject *resultobj;
41023 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41024 int arg2 ;
41025 PyObject * obj0 = 0 ;
41026 PyObject * obj1 = 0 ;
41027 char *kwnames[] = {
41028 (char *) "self",(char *) "gap", NULL
41029 };
41030
41031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41033 if (SWIG_arg_fail(1)) SWIG_fail;
41034 {
41035 arg2 = (int)(SWIG_As_int(obj1));
41036 if (SWIG_arg_fail(2)) SWIG_fail;
41037 }
41038 {
41039 PyThreadState* __tstate = wxPyBeginAllowThreads();
41040 (arg1)->SetHGap(arg2);
41041
41042 wxPyEndAllowThreads(__tstate);
41043 if (PyErr_Occurred()) SWIG_fail;
41044 }
41045 Py_INCREF(Py_None); resultobj = Py_None;
41046 return resultobj;
41047 fail:
41048 return NULL;
41049 }
41050
41051
41052 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41053 PyObject *resultobj;
41054 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41055 int result;
41056 PyObject * obj0 = 0 ;
41057 char *kwnames[] = {
41058 (char *) "self", NULL
41059 };
41060
41061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41063 if (SWIG_arg_fail(1)) SWIG_fail;
41064 {
41065 PyThreadState* __tstate = wxPyBeginAllowThreads();
41066 result = (int)(arg1)->GetCols();
41067
41068 wxPyEndAllowThreads(__tstate);
41069 if (PyErr_Occurred()) SWIG_fail;
41070 }
41071 {
41072 resultobj = SWIG_From_int((int)(result));
41073 }
41074 return resultobj;
41075 fail:
41076 return NULL;
41077 }
41078
41079
41080 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41081 PyObject *resultobj;
41082 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41083 int result;
41084 PyObject * obj0 = 0 ;
41085 char *kwnames[] = {
41086 (char *) "self", NULL
41087 };
41088
41089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41091 if (SWIG_arg_fail(1)) SWIG_fail;
41092 {
41093 PyThreadState* __tstate = wxPyBeginAllowThreads();
41094 result = (int)(arg1)->GetRows();
41095
41096 wxPyEndAllowThreads(__tstate);
41097 if (PyErr_Occurred()) SWIG_fail;
41098 }
41099 {
41100 resultobj = SWIG_From_int((int)(result));
41101 }
41102 return resultobj;
41103 fail:
41104 return NULL;
41105 }
41106
41107
41108 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41109 PyObject *resultobj;
41110 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41111 int result;
41112 PyObject * obj0 = 0 ;
41113 char *kwnames[] = {
41114 (char *) "self", NULL
41115 };
41116
41117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41119 if (SWIG_arg_fail(1)) SWIG_fail;
41120 {
41121 PyThreadState* __tstate = wxPyBeginAllowThreads();
41122 result = (int)(arg1)->GetVGap();
41123
41124 wxPyEndAllowThreads(__tstate);
41125 if (PyErr_Occurred()) SWIG_fail;
41126 }
41127 {
41128 resultobj = SWIG_From_int((int)(result));
41129 }
41130 return resultobj;
41131 fail:
41132 return NULL;
41133 }
41134
41135
41136 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41137 PyObject *resultobj;
41138 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41139 int result;
41140 PyObject * obj0 = 0 ;
41141 char *kwnames[] = {
41142 (char *) "self", NULL
41143 };
41144
41145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41147 if (SWIG_arg_fail(1)) SWIG_fail;
41148 {
41149 PyThreadState* __tstate = wxPyBeginAllowThreads();
41150 result = (int)(arg1)->GetHGap();
41151
41152 wxPyEndAllowThreads(__tstate);
41153 if (PyErr_Occurred()) SWIG_fail;
41154 }
41155 {
41156 resultobj = SWIG_From_int((int)(result));
41157 }
41158 return resultobj;
41159 fail:
41160 return NULL;
41161 }
41162
41163
41164 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41165 PyObject *obj;
41166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41167 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41168 Py_INCREF(obj);
41169 return Py_BuildValue((char *)"");
41170 }
41171 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41172 PyObject *resultobj;
41173 int arg1 = (int) 1 ;
41174 int arg2 = (int) 0 ;
41175 int arg3 = (int) 0 ;
41176 int arg4 = (int) 0 ;
41177 wxFlexGridSizer *result;
41178 PyObject * obj0 = 0 ;
41179 PyObject * obj1 = 0 ;
41180 PyObject * obj2 = 0 ;
41181 PyObject * obj3 = 0 ;
41182 char *kwnames[] = {
41183 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41184 };
41185
41186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41187 if (obj0) {
41188 {
41189 arg1 = (int)(SWIG_As_int(obj0));
41190 if (SWIG_arg_fail(1)) SWIG_fail;
41191 }
41192 }
41193 if (obj1) {
41194 {
41195 arg2 = (int)(SWIG_As_int(obj1));
41196 if (SWIG_arg_fail(2)) SWIG_fail;
41197 }
41198 }
41199 if (obj2) {
41200 {
41201 arg3 = (int)(SWIG_As_int(obj2));
41202 if (SWIG_arg_fail(3)) SWIG_fail;
41203 }
41204 }
41205 if (obj3) {
41206 {
41207 arg4 = (int)(SWIG_As_int(obj3));
41208 if (SWIG_arg_fail(4)) SWIG_fail;
41209 }
41210 }
41211 {
41212 PyThreadState* __tstate = wxPyBeginAllowThreads();
41213 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41214
41215 wxPyEndAllowThreads(__tstate);
41216 if (PyErr_Occurred()) SWIG_fail;
41217 }
41218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41219 return resultobj;
41220 fail:
41221 return NULL;
41222 }
41223
41224
41225 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41226 PyObject *resultobj;
41227 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41228 size_t arg2 ;
41229 int arg3 = (int) 0 ;
41230 PyObject * obj0 = 0 ;
41231 PyObject * obj1 = 0 ;
41232 PyObject * obj2 = 0 ;
41233 char *kwnames[] = {
41234 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41235 };
41236
41237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41239 if (SWIG_arg_fail(1)) SWIG_fail;
41240 {
41241 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41242 if (SWIG_arg_fail(2)) SWIG_fail;
41243 }
41244 if (obj2) {
41245 {
41246 arg3 = (int)(SWIG_As_int(obj2));
41247 if (SWIG_arg_fail(3)) SWIG_fail;
41248 }
41249 }
41250 {
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 (arg1)->AddGrowableRow(arg2,arg3);
41253
41254 wxPyEndAllowThreads(__tstate);
41255 if (PyErr_Occurred()) SWIG_fail;
41256 }
41257 Py_INCREF(Py_None); resultobj = Py_None;
41258 return resultobj;
41259 fail:
41260 return NULL;
41261 }
41262
41263
41264 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj;
41266 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41267 size_t arg2 ;
41268 PyObject * obj0 = 0 ;
41269 PyObject * obj1 = 0 ;
41270 char *kwnames[] = {
41271 (char *) "self",(char *) "idx", NULL
41272 };
41273
41274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41276 if (SWIG_arg_fail(1)) SWIG_fail;
41277 {
41278 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41279 if (SWIG_arg_fail(2)) SWIG_fail;
41280 }
41281 {
41282 PyThreadState* __tstate = wxPyBeginAllowThreads();
41283 (arg1)->RemoveGrowableRow(arg2);
41284
41285 wxPyEndAllowThreads(__tstate);
41286 if (PyErr_Occurred()) SWIG_fail;
41287 }
41288 Py_INCREF(Py_None); resultobj = Py_None;
41289 return resultobj;
41290 fail:
41291 return NULL;
41292 }
41293
41294
41295 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41296 PyObject *resultobj;
41297 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41298 size_t arg2 ;
41299 int arg3 = (int) 0 ;
41300 PyObject * obj0 = 0 ;
41301 PyObject * obj1 = 0 ;
41302 PyObject * obj2 = 0 ;
41303 char *kwnames[] = {
41304 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41305 };
41306
41307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41309 if (SWIG_arg_fail(1)) SWIG_fail;
41310 {
41311 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41312 if (SWIG_arg_fail(2)) SWIG_fail;
41313 }
41314 if (obj2) {
41315 {
41316 arg3 = (int)(SWIG_As_int(obj2));
41317 if (SWIG_arg_fail(3)) SWIG_fail;
41318 }
41319 }
41320 {
41321 PyThreadState* __tstate = wxPyBeginAllowThreads();
41322 (arg1)->AddGrowableCol(arg2,arg3);
41323
41324 wxPyEndAllowThreads(__tstate);
41325 if (PyErr_Occurred()) SWIG_fail;
41326 }
41327 Py_INCREF(Py_None); resultobj = Py_None;
41328 return resultobj;
41329 fail:
41330 return NULL;
41331 }
41332
41333
41334 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41335 PyObject *resultobj;
41336 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41337 size_t arg2 ;
41338 PyObject * obj0 = 0 ;
41339 PyObject * obj1 = 0 ;
41340 char *kwnames[] = {
41341 (char *) "self",(char *) "idx", NULL
41342 };
41343
41344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41346 if (SWIG_arg_fail(1)) SWIG_fail;
41347 {
41348 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41349 if (SWIG_arg_fail(2)) SWIG_fail;
41350 }
41351 {
41352 PyThreadState* __tstate = wxPyBeginAllowThreads();
41353 (arg1)->RemoveGrowableCol(arg2);
41354
41355 wxPyEndAllowThreads(__tstate);
41356 if (PyErr_Occurred()) SWIG_fail;
41357 }
41358 Py_INCREF(Py_None); resultobj = Py_None;
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41366 PyObject *resultobj;
41367 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41368 int arg2 ;
41369 PyObject * obj0 = 0 ;
41370 PyObject * obj1 = 0 ;
41371 char *kwnames[] = {
41372 (char *) "self",(char *) "direction", NULL
41373 };
41374
41375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41377 if (SWIG_arg_fail(1)) SWIG_fail;
41378 {
41379 arg2 = (int)(SWIG_As_int(obj1));
41380 if (SWIG_arg_fail(2)) SWIG_fail;
41381 }
41382 {
41383 PyThreadState* __tstate = wxPyBeginAllowThreads();
41384 (arg1)->SetFlexibleDirection(arg2);
41385
41386 wxPyEndAllowThreads(__tstate);
41387 if (PyErr_Occurred()) SWIG_fail;
41388 }
41389 Py_INCREF(Py_None); resultobj = Py_None;
41390 return resultobj;
41391 fail:
41392 return NULL;
41393 }
41394
41395
41396 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41397 PyObject *resultobj;
41398 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41399 int result;
41400 PyObject * obj0 = 0 ;
41401 char *kwnames[] = {
41402 (char *) "self", NULL
41403 };
41404
41405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41407 if (SWIG_arg_fail(1)) SWIG_fail;
41408 {
41409 PyThreadState* __tstate = wxPyBeginAllowThreads();
41410 result = (int)(arg1)->GetFlexibleDirection();
41411
41412 wxPyEndAllowThreads(__tstate);
41413 if (PyErr_Occurred()) SWIG_fail;
41414 }
41415 {
41416 resultobj = SWIG_From_int((int)(result));
41417 }
41418 return resultobj;
41419 fail:
41420 return NULL;
41421 }
41422
41423
41424 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41425 PyObject *resultobj;
41426 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41427 wxFlexSizerGrowMode arg2 ;
41428 PyObject * obj0 = 0 ;
41429 PyObject * obj1 = 0 ;
41430 char *kwnames[] = {
41431 (char *) "self",(char *) "mode", NULL
41432 };
41433
41434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41436 if (SWIG_arg_fail(1)) SWIG_fail;
41437 {
41438 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41439 if (SWIG_arg_fail(2)) SWIG_fail;
41440 }
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41444
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 Py_INCREF(Py_None); resultobj = Py_None;
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41456 PyObject *resultobj;
41457 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41458 wxFlexSizerGrowMode result;
41459 PyObject * obj0 = 0 ;
41460 char *kwnames[] = {
41461 (char *) "self", NULL
41462 };
41463
41464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41466 if (SWIG_arg_fail(1)) SWIG_fail;
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41470
41471 wxPyEndAllowThreads(__tstate);
41472 if (PyErr_Occurred()) SWIG_fail;
41473 }
41474 resultobj = SWIG_From_int((result));
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41482 PyObject *resultobj;
41483 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41484 wxArrayInt *result;
41485 PyObject * obj0 = 0 ;
41486 char *kwnames[] = {
41487 (char *) "self", NULL
41488 };
41489
41490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41492 if (SWIG_arg_fail(1)) SWIG_fail;
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 {
41496 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41497 result = (wxArrayInt *) &_result_ref;
41498 }
41499
41500 wxPyEndAllowThreads(__tstate);
41501 if (PyErr_Occurred()) SWIG_fail;
41502 }
41503 {
41504 resultobj = PyList_New(0);
41505 size_t idx;
41506 for (idx = 0; idx < result->GetCount(); idx += 1) {
41507 PyObject* val = PyInt_FromLong( result->Item(idx) );
41508 PyList_Append(resultobj, val);
41509 Py_DECREF(val);
41510 }
41511 }
41512 return resultobj;
41513 fail:
41514 return NULL;
41515 }
41516
41517
41518 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41519 PyObject *resultobj;
41520 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41521 wxArrayInt *result;
41522 PyObject * obj0 = 0 ;
41523 char *kwnames[] = {
41524 (char *) "self", NULL
41525 };
41526
41527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41529 if (SWIG_arg_fail(1)) SWIG_fail;
41530 {
41531 PyThreadState* __tstate = wxPyBeginAllowThreads();
41532 {
41533 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41534 result = (wxArrayInt *) &_result_ref;
41535 }
41536
41537 wxPyEndAllowThreads(__tstate);
41538 if (PyErr_Occurred()) SWIG_fail;
41539 }
41540 {
41541 resultobj = PyList_New(0);
41542 size_t idx;
41543 for (idx = 0; idx < result->GetCount(); idx += 1) {
41544 PyObject* val = PyInt_FromLong( result->Item(idx) );
41545 PyList_Append(resultobj, val);
41546 Py_DECREF(val);
41547 }
41548 }
41549 return resultobj;
41550 fail:
41551 return NULL;
41552 }
41553
41554
41555 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41556 PyObject *obj;
41557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41558 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41559 Py_INCREF(obj);
41560 return Py_BuildValue((char *)"");
41561 }
41562 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41563 PyObject *resultobj;
41564 wxStdDialogButtonSizer *result;
41565 char *kwnames[] = {
41566 NULL
41567 };
41568
41569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41570 {
41571 PyThreadState* __tstate = wxPyBeginAllowThreads();
41572 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41573
41574 wxPyEndAllowThreads(__tstate);
41575 if (PyErr_Occurred()) SWIG_fail;
41576 }
41577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41578 return resultobj;
41579 fail:
41580 return NULL;
41581 }
41582
41583
41584 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41585 PyObject *resultobj;
41586 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41587 wxButton *arg2 = (wxButton *) 0 ;
41588 PyObject * obj0 = 0 ;
41589 PyObject * obj1 = 0 ;
41590 char *kwnames[] = {
41591 (char *) "self",(char *) "button", NULL
41592 };
41593
41594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41596 if (SWIG_arg_fail(1)) SWIG_fail;
41597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41598 if (SWIG_arg_fail(2)) SWIG_fail;
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 (arg1)->AddButton(arg2);
41602
41603 wxPyEndAllowThreads(__tstate);
41604 if (PyErr_Occurred()) SWIG_fail;
41605 }
41606 Py_INCREF(Py_None); resultobj = Py_None;
41607 return resultobj;
41608 fail:
41609 return NULL;
41610 }
41611
41612
41613 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41614 PyObject *resultobj;
41615 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41616 PyObject * obj0 = 0 ;
41617 char *kwnames[] = {
41618 (char *) "self", NULL
41619 };
41620
41621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41623 if (SWIG_arg_fail(1)) SWIG_fail;
41624 {
41625 PyThreadState* __tstate = wxPyBeginAllowThreads();
41626 (arg1)->Realize();
41627
41628 wxPyEndAllowThreads(__tstate);
41629 if (PyErr_Occurred()) SWIG_fail;
41630 }
41631 Py_INCREF(Py_None); resultobj = Py_None;
41632 return resultobj;
41633 fail:
41634 return NULL;
41635 }
41636
41637
41638 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41639 PyObject *resultobj;
41640 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41641 wxButton *arg2 = (wxButton *) 0 ;
41642 PyObject * obj0 = 0 ;
41643 PyObject * obj1 = 0 ;
41644 char *kwnames[] = {
41645 (char *) "self",(char *) "button", NULL
41646 };
41647
41648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41650 if (SWIG_arg_fail(1)) SWIG_fail;
41651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41652 if (SWIG_arg_fail(2)) SWIG_fail;
41653 {
41654 PyThreadState* __tstate = wxPyBeginAllowThreads();
41655 (arg1)->SetAffirmativeButton(arg2);
41656
41657 wxPyEndAllowThreads(__tstate);
41658 if (PyErr_Occurred()) SWIG_fail;
41659 }
41660 Py_INCREF(Py_None); resultobj = Py_None;
41661 return resultobj;
41662 fail:
41663 return NULL;
41664 }
41665
41666
41667 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41668 PyObject *resultobj;
41669 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41670 wxButton *arg2 = (wxButton *) 0 ;
41671 PyObject * obj0 = 0 ;
41672 PyObject * obj1 = 0 ;
41673 char *kwnames[] = {
41674 (char *) "self",(char *) "button", NULL
41675 };
41676
41677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41679 if (SWIG_arg_fail(1)) SWIG_fail;
41680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41681 if (SWIG_arg_fail(2)) SWIG_fail;
41682 {
41683 PyThreadState* __tstate = wxPyBeginAllowThreads();
41684 (arg1)->SetNegativeButton(arg2);
41685
41686 wxPyEndAllowThreads(__tstate);
41687 if (PyErr_Occurred()) SWIG_fail;
41688 }
41689 Py_INCREF(Py_None); resultobj = Py_None;
41690 return resultobj;
41691 fail:
41692 return NULL;
41693 }
41694
41695
41696 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41697 PyObject *resultobj;
41698 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41699 wxButton *arg2 = (wxButton *) 0 ;
41700 PyObject * obj0 = 0 ;
41701 PyObject * obj1 = 0 ;
41702 char *kwnames[] = {
41703 (char *) "self",(char *) "button", NULL
41704 };
41705
41706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41708 if (SWIG_arg_fail(1)) SWIG_fail;
41709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41710 if (SWIG_arg_fail(2)) SWIG_fail;
41711 {
41712 PyThreadState* __tstate = wxPyBeginAllowThreads();
41713 (arg1)->SetCancelButton(arg2);
41714
41715 wxPyEndAllowThreads(__tstate);
41716 if (PyErr_Occurred()) SWIG_fail;
41717 }
41718 Py_INCREF(Py_None); resultobj = Py_None;
41719 return resultobj;
41720 fail:
41721 return NULL;
41722 }
41723
41724
41725 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41726 PyObject *resultobj;
41727 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41728 wxButton *result;
41729 PyObject * obj0 = 0 ;
41730 char *kwnames[] = {
41731 (char *) "self", NULL
41732 };
41733
41734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41736 if (SWIG_arg_fail(1)) SWIG_fail;
41737 {
41738 PyThreadState* __tstate = wxPyBeginAllowThreads();
41739 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41740
41741 wxPyEndAllowThreads(__tstate);
41742 if (PyErr_Occurred()) SWIG_fail;
41743 }
41744 {
41745 resultobj = wxPyMake_wxObject(result, 0);
41746 }
41747 return resultobj;
41748 fail:
41749 return NULL;
41750 }
41751
41752
41753 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41754 PyObject *resultobj;
41755 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41756 wxButton *result;
41757 PyObject * obj0 = 0 ;
41758 char *kwnames[] = {
41759 (char *) "self", NULL
41760 };
41761
41762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41764 if (SWIG_arg_fail(1)) SWIG_fail;
41765 {
41766 PyThreadState* __tstate = wxPyBeginAllowThreads();
41767 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41768
41769 wxPyEndAllowThreads(__tstate);
41770 if (PyErr_Occurred()) SWIG_fail;
41771 }
41772 {
41773 resultobj = wxPyMake_wxObject(result, 0);
41774 }
41775 return resultobj;
41776 fail:
41777 return NULL;
41778 }
41779
41780
41781 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41782 PyObject *resultobj;
41783 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41784 wxButton *result;
41785 PyObject * obj0 = 0 ;
41786 char *kwnames[] = {
41787 (char *) "self", NULL
41788 };
41789
41790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41792 if (SWIG_arg_fail(1)) SWIG_fail;
41793 {
41794 PyThreadState* __tstate = wxPyBeginAllowThreads();
41795 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41796
41797 wxPyEndAllowThreads(__tstate);
41798 if (PyErr_Occurred()) SWIG_fail;
41799 }
41800 {
41801 resultobj = wxPyMake_wxObject(result, 0);
41802 }
41803 return resultobj;
41804 fail:
41805 return NULL;
41806 }
41807
41808
41809 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41810 PyObject *resultobj;
41811 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41812 wxButton *result;
41813 PyObject * obj0 = 0 ;
41814 char *kwnames[] = {
41815 (char *) "self", NULL
41816 };
41817
41818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41820 if (SWIG_arg_fail(1)) SWIG_fail;
41821 {
41822 PyThreadState* __tstate = wxPyBeginAllowThreads();
41823 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41824
41825 wxPyEndAllowThreads(__tstate);
41826 if (PyErr_Occurred()) SWIG_fail;
41827 }
41828 {
41829 resultobj = wxPyMake_wxObject(result, 0);
41830 }
41831 return resultobj;
41832 fail:
41833 return NULL;
41834 }
41835
41836
41837 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41838 PyObject *resultobj;
41839 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41840 wxButton *result;
41841 PyObject * obj0 = 0 ;
41842 char *kwnames[] = {
41843 (char *) "self", NULL
41844 };
41845
41846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41848 if (SWIG_arg_fail(1)) SWIG_fail;
41849 {
41850 PyThreadState* __tstate = wxPyBeginAllowThreads();
41851 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41852
41853 wxPyEndAllowThreads(__tstate);
41854 if (PyErr_Occurred()) SWIG_fail;
41855 }
41856 {
41857 resultobj = wxPyMake_wxObject(result, 0);
41858 }
41859 return resultobj;
41860 fail:
41861 return NULL;
41862 }
41863
41864
41865 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41866 PyObject *obj;
41867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41868 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41869 Py_INCREF(obj);
41870 return Py_BuildValue((char *)"");
41871 }
41872 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj;
41874 int arg1 = (int) 0 ;
41875 int arg2 = (int) 0 ;
41876 wxGBPosition *result;
41877 PyObject * obj0 = 0 ;
41878 PyObject * obj1 = 0 ;
41879 char *kwnames[] = {
41880 (char *) "row",(char *) "col", NULL
41881 };
41882
41883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41884 if (obj0) {
41885 {
41886 arg1 = (int)(SWIG_As_int(obj0));
41887 if (SWIG_arg_fail(1)) SWIG_fail;
41888 }
41889 }
41890 if (obj1) {
41891 {
41892 arg2 = (int)(SWIG_As_int(obj1));
41893 if (SWIG_arg_fail(2)) SWIG_fail;
41894 }
41895 }
41896 {
41897 PyThreadState* __tstate = wxPyBeginAllowThreads();
41898 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41899
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41904 return resultobj;
41905 fail:
41906 return NULL;
41907 }
41908
41909
41910 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41911 PyObject *resultobj;
41912 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41913 int result;
41914 PyObject * obj0 = 0 ;
41915 char *kwnames[] = {
41916 (char *) "self", NULL
41917 };
41918
41919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41921 if (SWIG_arg_fail(1)) SWIG_fail;
41922 {
41923 PyThreadState* __tstate = wxPyBeginAllowThreads();
41924 result = (int)((wxGBPosition const *)arg1)->GetRow();
41925
41926 wxPyEndAllowThreads(__tstate);
41927 if (PyErr_Occurred()) SWIG_fail;
41928 }
41929 {
41930 resultobj = SWIG_From_int((int)(result));
41931 }
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj;
41940 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41941 int result;
41942 PyObject * obj0 = 0 ;
41943 char *kwnames[] = {
41944 (char *) "self", NULL
41945 };
41946
41947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41949 if (SWIG_arg_fail(1)) SWIG_fail;
41950 {
41951 PyThreadState* __tstate = wxPyBeginAllowThreads();
41952 result = (int)((wxGBPosition const *)arg1)->GetCol();
41953
41954 wxPyEndAllowThreads(__tstate);
41955 if (PyErr_Occurred()) SWIG_fail;
41956 }
41957 {
41958 resultobj = SWIG_From_int((int)(result));
41959 }
41960 return resultobj;
41961 fail:
41962 return NULL;
41963 }
41964
41965
41966 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41967 PyObject *resultobj;
41968 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41969 int arg2 ;
41970 PyObject * obj0 = 0 ;
41971 PyObject * obj1 = 0 ;
41972 char *kwnames[] = {
41973 (char *) "self",(char *) "row", NULL
41974 };
41975
41976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41978 if (SWIG_arg_fail(1)) SWIG_fail;
41979 {
41980 arg2 = (int)(SWIG_As_int(obj1));
41981 if (SWIG_arg_fail(2)) SWIG_fail;
41982 }
41983 {
41984 PyThreadState* __tstate = wxPyBeginAllowThreads();
41985 (arg1)->SetRow(arg2);
41986
41987 wxPyEndAllowThreads(__tstate);
41988 if (PyErr_Occurred()) SWIG_fail;
41989 }
41990 Py_INCREF(Py_None); resultobj = Py_None;
41991 return resultobj;
41992 fail:
41993 return NULL;
41994 }
41995
41996
41997 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41998 PyObject *resultobj;
41999 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42000 int arg2 ;
42001 PyObject * obj0 = 0 ;
42002 PyObject * obj1 = 0 ;
42003 char *kwnames[] = {
42004 (char *) "self",(char *) "col", NULL
42005 };
42006
42007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42009 if (SWIG_arg_fail(1)) SWIG_fail;
42010 {
42011 arg2 = (int)(SWIG_As_int(obj1));
42012 if (SWIG_arg_fail(2)) SWIG_fail;
42013 }
42014 {
42015 PyThreadState* __tstate = wxPyBeginAllowThreads();
42016 (arg1)->SetCol(arg2);
42017
42018 wxPyEndAllowThreads(__tstate);
42019 if (PyErr_Occurred()) SWIG_fail;
42020 }
42021 Py_INCREF(Py_None); resultobj = Py_None;
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42029 PyObject *resultobj;
42030 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42031 wxGBPosition *arg2 = 0 ;
42032 bool result;
42033 wxGBPosition temp2 ;
42034 PyObject * obj0 = 0 ;
42035 PyObject * obj1 = 0 ;
42036 char *kwnames[] = {
42037 (char *) "self",(char *) "other", NULL
42038 };
42039
42040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42042 if (SWIG_arg_fail(1)) SWIG_fail;
42043 {
42044 arg2 = &temp2;
42045 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42046 }
42047 {
42048 PyThreadState* __tstate = wxPyBeginAllowThreads();
42049 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42050
42051 wxPyEndAllowThreads(__tstate);
42052 if (PyErr_Occurred()) SWIG_fail;
42053 }
42054 {
42055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42056 }
42057 return resultobj;
42058 fail:
42059 return NULL;
42060 }
42061
42062
42063 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42064 PyObject *resultobj;
42065 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42066 wxGBPosition *arg2 = 0 ;
42067 bool result;
42068 wxGBPosition temp2 ;
42069 PyObject * obj0 = 0 ;
42070 PyObject * obj1 = 0 ;
42071 char *kwnames[] = {
42072 (char *) "self",(char *) "other", NULL
42073 };
42074
42075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42077 if (SWIG_arg_fail(1)) SWIG_fail;
42078 {
42079 arg2 = &temp2;
42080 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42081 }
42082 {
42083 PyThreadState* __tstate = wxPyBeginAllowThreads();
42084 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42085
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 {
42090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42091 }
42092 return resultobj;
42093 fail:
42094 return NULL;
42095 }
42096
42097
42098 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42099 PyObject *resultobj;
42100 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42101 int arg2 = (int) 0 ;
42102 int arg3 = (int) 0 ;
42103 PyObject * obj0 = 0 ;
42104 PyObject * obj1 = 0 ;
42105 PyObject * obj2 = 0 ;
42106 char *kwnames[] = {
42107 (char *) "self",(char *) "row",(char *) "col", NULL
42108 };
42109
42110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42112 if (SWIG_arg_fail(1)) SWIG_fail;
42113 if (obj1) {
42114 {
42115 arg2 = (int)(SWIG_As_int(obj1));
42116 if (SWIG_arg_fail(2)) SWIG_fail;
42117 }
42118 }
42119 if (obj2) {
42120 {
42121 arg3 = (int)(SWIG_As_int(obj2));
42122 if (SWIG_arg_fail(3)) SWIG_fail;
42123 }
42124 }
42125 {
42126 PyThreadState* __tstate = wxPyBeginAllowThreads();
42127 wxGBPosition_Set(arg1,arg2,arg3);
42128
42129 wxPyEndAllowThreads(__tstate);
42130 if (PyErr_Occurred()) SWIG_fail;
42131 }
42132 Py_INCREF(Py_None); resultobj = Py_None;
42133 return resultobj;
42134 fail:
42135 return NULL;
42136 }
42137
42138
42139 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42140 PyObject *resultobj;
42141 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42142 PyObject *result;
42143 PyObject * obj0 = 0 ;
42144 char *kwnames[] = {
42145 (char *) "self", NULL
42146 };
42147
42148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42150 if (SWIG_arg_fail(1)) SWIG_fail;
42151 {
42152 PyThreadState* __tstate = wxPyBeginAllowThreads();
42153 result = (PyObject *)wxGBPosition_Get(arg1);
42154
42155 wxPyEndAllowThreads(__tstate);
42156 if (PyErr_Occurred()) SWIG_fail;
42157 }
42158 resultobj = result;
42159 return resultobj;
42160 fail:
42161 return NULL;
42162 }
42163
42164
42165 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42166 PyObject *obj;
42167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42168 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42169 Py_INCREF(obj);
42170 return Py_BuildValue((char *)"");
42171 }
42172 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42173 PyObject *resultobj;
42174 int arg1 = (int) 1 ;
42175 int arg2 = (int) 1 ;
42176 wxGBSpan *result;
42177 PyObject * obj0 = 0 ;
42178 PyObject * obj1 = 0 ;
42179 char *kwnames[] = {
42180 (char *) "rowspan",(char *) "colspan", NULL
42181 };
42182
42183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42184 if (obj0) {
42185 {
42186 arg1 = (int)(SWIG_As_int(obj0));
42187 if (SWIG_arg_fail(1)) SWIG_fail;
42188 }
42189 }
42190 if (obj1) {
42191 {
42192 arg2 = (int)(SWIG_As_int(obj1));
42193 if (SWIG_arg_fail(2)) SWIG_fail;
42194 }
42195 }
42196 {
42197 PyThreadState* __tstate = wxPyBeginAllowThreads();
42198 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42199
42200 wxPyEndAllowThreads(__tstate);
42201 if (PyErr_Occurred()) SWIG_fail;
42202 }
42203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42204 return resultobj;
42205 fail:
42206 return NULL;
42207 }
42208
42209
42210 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42211 PyObject *resultobj;
42212 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42213 int result;
42214 PyObject * obj0 = 0 ;
42215 char *kwnames[] = {
42216 (char *) "self", NULL
42217 };
42218
42219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42221 if (SWIG_arg_fail(1)) SWIG_fail;
42222 {
42223 PyThreadState* __tstate = wxPyBeginAllowThreads();
42224 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42225
42226 wxPyEndAllowThreads(__tstate);
42227 if (PyErr_Occurred()) SWIG_fail;
42228 }
42229 {
42230 resultobj = SWIG_From_int((int)(result));
42231 }
42232 return resultobj;
42233 fail:
42234 return NULL;
42235 }
42236
42237
42238 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42239 PyObject *resultobj;
42240 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42241 int result;
42242 PyObject * obj0 = 0 ;
42243 char *kwnames[] = {
42244 (char *) "self", NULL
42245 };
42246
42247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42249 if (SWIG_arg_fail(1)) SWIG_fail;
42250 {
42251 PyThreadState* __tstate = wxPyBeginAllowThreads();
42252 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42253
42254 wxPyEndAllowThreads(__tstate);
42255 if (PyErr_Occurred()) SWIG_fail;
42256 }
42257 {
42258 resultobj = SWIG_From_int((int)(result));
42259 }
42260 return resultobj;
42261 fail:
42262 return NULL;
42263 }
42264
42265
42266 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42267 PyObject *resultobj;
42268 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42269 int arg2 ;
42270 PyObject * obj0 = 0 ;
42271 PyObject * obj1 = 0 ;
42272 char *kwnames[] = {
42273 (char *) "self",(char *) "rowspan", NULL
42274 };
42275
42276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42278 if (SWIG_arg_fail(1)) SWIG_fail;
42279 {
42280 arg2 = (int)(SWIG_As_int(obj1));
42281 if (SWIG_arg_fail(2)) SWIG_fail;
42282 }
42283 {
42284 PyThreadState* __tstate = wxPyBeginAllowThreads();
42285 (arg1)->SetRowspan(arg2);
42286
42287 wxPyEndAllowThreads(__tstate);
42288 if (PyErr_Occurred()) SWIG_fail;
42289 }
42290 Py_INCREF(Py_None); resultobj = Py_None;
42291 return resultobj;
42292 fail:
42293 return NULL;
42294 }
42295
42296
42297 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42298 PyObject *resultobj;
42299 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42300 int arg2 ;
42301 PyObject * obj0 = 0 ;
42302 PyObject * obj1 = 0 ;
42303 char *kwnames[] = {
42304 (char *) "self",(char *) "colspan", NULL
42305 };
42306
42307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42309 if (SWIG_arg_fail(1)) SWIG_fail;
42310 {
42311 arg2 = (int)(SWIG_As_int(obj1));
42312 if (SWIG_arg_fail(2)) SWIG_fail;
42313 }
42314 {
42315 PyThreadState* __tstate = wxPyBeginAllowThreads();
42316 (arg1)->SetColspan(arg2);
42317
42318 wxPyEndAllowThreads(__tstate);
42319 if (PyErr_Occurred()) SWIG_fail;
42320 }
42321 Py_INCREF(Py_None); resultobj = Py_None;
42322 return resultobj;
42323 fail:
42324 return NULL;
42325 }
42326
42327
42328 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42329 PyObject *resultobj;
42330 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42331 wxGBSpan *arg2 = 0 ;
42332 bool result;
42333 wxGBSpan temp2 ;
42334 PyObject * obj0 = 0 ;
42335 PyObject * obj1 = 0 ;
42336 char *kwnames[] = {
42337 (char *) "self",(char *) "other", NULL
42338 };
42339
42340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42342 if (SWIG_arg_fail(1)) SWIG_fail;
42343 {
42344 arg2 = &temp2;
42345 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42346 }
42347 {
42348 PyThreadState* __tstate = wxPyBeginAllowThreads();
42349 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42350
42351 wxPyEndAllowThreads(__tstate);
42352 if (PyErr_Occurred()) SWIG_fail;
42353 }
42354 {
42355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42356 }
42357 return resultobj;
42358 fail:
42359 return NULL;
42360 }
42361
42362
42363 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42364 PyObject *resultobj;
42365 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42366 wxGBSpan *arg2 = 0 ;
42367 bool result;
42368 wxGBSpan temp2 ;
42369 PyObject * obj0 = 0 ;
42370 PyObject * obj1 = 0 ;
42371 char *kwnames[] = {
42372 (char *) "self",(char *) "other", NULL
42373 };
42374
42375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42377 if (SWIG_arg_fail(1)) SWIG_fail;
42378 {
42379 arg2 = &temp2;
42380 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42381 }
42382 {
42383 PyThreadState* __tstate = wxPyBeginAllowThreads();
42384 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42385
42386 wxPyEndAllowThreads(__tstate);
42387 if (PyErr_Occurred()) SWIG_fail;
42388 }
42389 {
42390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42391 }
42392 return resultobj;
42393 fail:
42394 return NULL;
42395 }
42396
42397
42398 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42399 PyObject *resultobj;
42400 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42401 int arg2 = (int) 1 ;
42402 int arg3 = (int) 1 ;
42403 PyObject * obj0 = 0 ;
42404 PyObject * obj1 = 0 ;
42405 PyObject * obj2 = 0 ;
42406 char *kwnames[] = {
42407 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42408 };
42409
42410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42412 if (SWIG_arg_fail(1)) SWIG_fail;
42413 if (obj1) {
42414 {
42415 arg2 = (int)(SWIG_As_int(obj1));
42416 if (SWIG_arg_fail(2)) SWIG_fail;
42417 }
42418 }
42419 if (obj2) {
42420 {
42421 arg3 = (int)(SWIG_As_int(obj2));
42422 if (SWIG_arg_fail(3)) SWIG_fail;
42423 }
42424 }
42425 {
42426 PyThreadState* __tstate = wxPyBeginAllowThreads();
42427 wxGBSpan_Set(arg1,arg2,arg3);
42428
42429 wxPyEndAllowThreads(__tstate);
42430 if (PyErr_Occurred()) SWIG_fail;
42431 }
42432 Py_INCREF(Py_None); resultobj = Py_None;
42433 return resultobj;
42434 fail:
42435 return NULL;
42436 }
42437
42438
42439 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42440 PyObject *resultobj;
42441 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42442 PyObject *result;
42443 PyObject * obj0 = 0 ;
42444 char *kwnames[] = {
42445 (char *) "self", NULL
42446 };
42447
42448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42450 if (SWIG_arg_fail(1)) SWIG_fail;
42451 {
42452 PyThreadState* __tstate = wxPyBeginAllowThreads();
42453 result = (PyObject *)wxGBSpan_Get(arg1);
42454
42455 wxPyEndAllowThreads(__tstate);
42456 if (PyErr_Occurred()) SWIG_fail;
42457 }
42458 resultobj = result;
42459 return resultobj;
42460 fail:
42461 return NULL;
42462 }
42463
42464
42465 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42466 PyObject *obj;
42467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42468 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42469 Py_INCREF(obj);
42470 return Py_BuildValue((char *)"");
42471 }
42472 static int _wrap_DefaultSpan_set(PyObject *) {
42473 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42474 return 1;
42475 }
42476
42477
42478 static PyObject *_wrap_DefaultSpan_get(void) {
42479 PyObject *pyobj;
42480
42481 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42482 return pyobj;
42483 }
42484
42485
42486 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42487 PyObject *resultobj;
42488 wxGBSizerItem *result;
42489 char *kwnames[] = {
42490 NULL
42491 };
42492
42493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42494 {
42495 PyThreadState* __tstate = wxPyBeginAllowThreads();
42496 result = (wxGBSizerItem *)new wxGBSizerItem();
42497
42498 wxPyEndAllowThreads(__tstate);
42499 if (PyErr_Occurred()) SWIG_fail;
42500 }
42501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42502 return resultobj;
42503 fail:
42504 return NULL;
42505 }
42506
42507
42508 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42509 PyObject *resultobj;
42510 wxWindow *arg1 = (wxWindow *) 0 ;
42511 wxGBPosition *arg2 = 0 ;
42512 wxGBSpan *arg3 = 0 ;
42513 int arg4 ;
42514 int arg5 ;
42515 PyObject *arg6 = (PyObject *) NULL ;
42516 wxGBSizerItem *result;
42517 wxGBPosition temp2 ;
42518 wxGBSpan temp3 ;
42519 PyObject * obj0 = 0 ;
42520 PyObject * obj1 = 0 ;
42521 PyObject * obj2 = 0 ;
42522 PyObject * obj3 = 0 ;
42523 PyObject * obj4 = 0 ;
42524 PyObject * obj5 = 0 ;
42525 char *kwnames[] = {
42526 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42527 };
42528
42529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42531 if (SWIG_arg_fail(1)) SWIG_fail;
42532 {
42533 arg2 = &temp2;
42534 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42535 }
42536 {
42537 arg3 = &temp3;
42538 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42539 }
42540 {
42541 arg4 = (int)(SWIG_As_int(obj3));
42542 if (SWIG_arg_fail(4)) SWIG_fail;
42543 }
42544 {
42545 arg5 = (int)(SWIG_As_int(obj4));
42546 if (SWIG_arg_fail(5)) SWIG_fail;
42547 }
42548 if (obj5) {
42549 arg6 = obj5;
42550 }
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42554
42555 wxPyEndAllowThreads(__tstate);
42556 if (PyErr_Occurred()) SWIG_fail;
42557 }
42558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42559 return resultobj;
42560 fail:
42561 return NULL;
42562 }
42563
42564
42565 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42566 PyObject *resultobj;
42567 wxSizer *arg1 = (wxSizer *) 0 ;
42568 wxGBPosition *arg2 = 0 ;
42569 wxGBSpan *arg3 = 0 ;
42570 int arg4 ;
42571 int arg5 ;
42572 PyObject *arg6 = (PyObject *) NULL ;
42573 wxGBSizerItem *result;
42574 wxGBPosition temp2 ;
42575 wxGBSpan temp3 ;
42576 PyObject * obj0 = 0 ;
42577 PyObject * obj1 = 0 ;
42578 PyObject * obj2 = 0 ;
42579 PyObject * obj3 = 0 ;
42580 PyObject * obj4 = 0 ;
42581 PyObject * obj5 = 0 ;
42582 char *kwnames[] = {
42583 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42584 };
42585
42586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42588 if (SWIG_arg_fail(1)) SWIG_fail;
42589 {
42590 arg2 = &temp2;
42591 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42592 }
42593 {
42594 arg3 = &temp3;
42595 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42596 }
42597 {
42598 arg4 = (int)(SWIG_As_int(obj3));
42599 if (SWIG_arg_fail(4)) SWIG_fail;
42600 }
42601 {
42602 arg5 = (int)(SWIG_As_int(obj4));
42603 if (SWIG_arg_fail(5)) SWIG_fail;
42604 }
42605 if (obj5) {
42606 arg6 = obj5;
42607 }
42608 {
42609 PyThreadState* __tstate = wxPyBeginAllowThreads();
42610 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42611
42612 wxPyEndAllowThreads(__tstate);
42613 if (PyErr_Occurred()) SWIG_fail;
42614 }
42615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42616 return resultobj;
42617 fail:
42618 return NULL;
42619 }
42620
42621
42622 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42623 PyObject *resultobj;
42624 int arg1 ;
42625 int arg2 ;
42626 wxGBPosition *arg3 = 0 ;
42627 wxGBSpan *arg4 = 0 ;
42628 int arg5 ;
42629 int arg6 ;
42630 PyObject *arg7 = (PyObject *) NULL ;
42631 wxGBSizerItem *result;
42632 wxGBPosition temp3 ;
42633 wxGBSpan temp4 ;
42634 PyObject * obj0 = 0 ;
42635 PyObject * obj1 = 0 ;
42636 PyObject * obj2 = 0 ;
42637 PyObject * obj3 = 0 ;
42638 PyObject * obj4 = 0 ;
42639 PyObject * obj5 = 0 ;
42640 PyObject * obj6 = 0 ;
42641 char *kwnames[] = {
42642 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42643 };
42644
42645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42646 {
42647 arg1 = (int)(SWIG_As_int(obj0));
42648 if (SWIG_arg_fail(1)) SWIG_fail;
42649 }
42650 {
42651 arg2 = (int)(SWIG_As_int(obj1));
42652 if (SWIG_arg_fail(2)) SWIG_fail;
42653 }
42654 {
42655 arg3 = &temp3;
42656 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42657 }
42658 {
42659 arg4 = &temp4;
42660 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42661 }
42662 {
42663 arg5 = (int)(SWIG_As_int(obj4));
42664 if (SWIG_arg_fail(5)) SWIG_fail;
42665 }
42666 {
42667 arg6 = (int)(SWIG_As_int(obj5));
42668 if (SWIG_arg_fail(6)) SWIG_fail;
42669 }
42670 if (obj6) {
42671 arg7 = obj6;
42672 }
42673 {
42674 PyThreadState* __tstate = wxPyBeginAllowThreads();
42675 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42676
42677 wxPyEndAllowThreads(__tstate);
42678 if (PyErr_Occurred()) SWIG_fail;
42679 }
42680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42681 return resultobj;
42682 fail:
42683 return NULL;
42684 }
42685
42686
42687 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42688 PyObject *resultobj;
42689 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42690 wxGBPosition result;
42691 PyObject * obj0 = 0 ;
42692 char *kwnames[] = {
42693 (char *) "self", NULL
42694 };
42695
42696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42698 if (SWIG_arg_fail(1)) SWIG_fail;
42699 {
42700 PyThreadState* __tstate = wxPyBeginAllowThreads();
42701 result = ((wxGBSizerItem const *)arg1)->GetPos();
42702
42703 wxPyEndAllowThreads(__tstate);
42704 if (PyErr_Occurred()) SWIG_fail;
42705 }
42706 {
42707 wxGBPosition * resultptr;
42708 resultptr = new wxGBPosition((wxGBPosition &)(result));
42709 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42710 }
42711 return resultobj;
42712 fail:
42713 return NULL;
42714 }
42715
42716
42717 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42718 PyObject *resultobj;
42719 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42720 wxGBSpan result;
42721 PyObject * obj0 = 0 ;
42722 char *kwnames[] = {
42723 (char *) "self", NULL
42724 };
42725
42726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42728 if (SWIG_arg_fail(1)) SWIG_fail;
42729 {
42730 PyThreadState* __tstate = wxPyBeginAllowThreads();
42731 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42732
42733 wxPyEndAllowThreads(__tstate);
42734 if (PyErr_Occurred()) SWIG_fail;
42735 }
42736 {
42737 wxGBSpan * resultptr;
42738 resultptr = new wxGBSpan((wxGBSpan &)(result));
42739 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42740 }
42741 return resultobj;
42742 fail:
42743 return NULL;
42744 }
42745
42746
42747 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42748 PyObject *resultobj;
42749 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42750 wxGBPosition *arg2 = 0 ;
42751 bool result;
42752 wxGBPosition temp2 ;
42753 PyObject * obj0 = 0 ;
42754 PyObject * obj1 = 0 ;
42755 char *kwnames[] = {
42756 (char *) "self",(char *) "pos", NULL
42757 };
42758
42759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42761 if (SWIG_arg_fail(1)) SWIG_fail;
42762 {
42763 arg2 = &temp2;
42764 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42765 }
42766 {
42767 PyThreadState* __tstate = wxPyBeginAllowThreads();
42768 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42769
42770 wxPyEndAllowThreads(__tstate);
42771 if (PyErr_Occurred()) SWIG_fail;
42772 }
42773 {
42774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42775 }
42776 return resultobj;
42777 fail:
42778 return NULL;
42779 }
42780
42781
42782 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42783 PyObject *resultobj;
42784 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42785 wxGBSpan *arg2 = 0 ;
42786 bool result;
42787 wxGBSpan temp2 ;
42788 PyObject * obj0 = 0 ;
42789 PyObject * obj1 = 0 ;
42790 char *kwnames[] = {
42791 (char *) "self",(char *) "span", NULL
42792 };
42793
42794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42796 if (SWIG_arg_fail(1)) SWIG_fail;
42797 {
42798 arg2 = &temp2;
42799 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42800 }
42801 {
42802 PyThreadState* __tstate = wxPyBeginAllowThreads();
42803 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42804
42805 wxPyEndAllowThreads(__tstate);
42806 if (PyErr_Occurred()) SWIG_fail;
42807 }
42808 {
42809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42810 }
42811 return resultobj;
42812 fail:
42813 return NULL;
42814 }
42815
42816
42817 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42818 PyObject *resultobj;
42819 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42820 wxGBSizerItem *arg2 = 0 ;
42821 bool result;
42822 PyObject * obj0 = 0 ;
42823 PyObject * obj1 = 0 ;
42824 char *kwnames[] = {
42825 (char *) "self",(char *) "other", NULL
42826 };
42827
42828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42830 if (SWIG_arg_fail(1)) SWIG_fail;
42831 {
42832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42833 if (SWIG_arg_fail(2)) SWIG_fail;
42834 if (arg2 == NULL) {
42835 SWIG_null_ref("wxGBSizerItem");
42836 }
42837 if (SWIG_arg_fail(2)) SWIG_fail;
42838 }
42839 {
42840 PyThreadState* __tstate = wxPyBeginAllowThreads();
42841 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42842
42843 wxPyEndAllowThreads(__tstate);
42844 if (PyErr_Occurred()) SWIG_fail;
42845 }
42846 {
42847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42848 }
42849 return resultobj;
42850 fail:
42851 return NULL;
42852 }
42853
42854
42855 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42856 PyObject *resultobj;
42857 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42858 wxGBPosition *arg2 = 0 ;
42859 wxGBSpan *arg3 = 0 ;
42860 bool result;
42861 wxGBPosition temp2 ;
42862 wxGBSpan temp3 ;
42863 PyObject * obj0 = 0 ;
42864 PyObject * obj1 = 0 ;
42865 PyObject * obj2 = 0 ;
42866 char *kwnames[] = {
42867 (char *) "self",(char *) "pos",(char *) "span", NULL
42868 };
42869
42870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42872 if (SWIG_arg_fail(1)) SWIG_fail;
42873 {
42874 arg2 = &temp2;
42875 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42876 }
42877 {
42878 arg3 = &temp3;
42879 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42880 }
42881 {
42882 PyThreadState* __tstate = wxPyBeginAllowThreads();
42883 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42884
42885 wxPyEndAllowThreads(__tstate);
42886 if (PyErr_Occurred()) SWIG_fail;
42887 }
42888 {
42889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42890 }
42891 return resultobj;
42892 fail:
42893 return NULL;
42894 }
42895
42896
42897 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42898 PyObject *resultobj;
42899 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42900 wxGBPosition result;
42901 PyObject * obj0 = 0 ;
42902 char *kwnames[] = {
42903 (char *) "self", NULL
42904 };
42905
42906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42908 if (SWIG_arg_fail(1)) SWIG_fail;
42909 {
42910 PyThreadState* __tstate = wxPyBeginAllowThreads();
42911 result = wxGBSizerItem_GetEndPos(arg1);
42912
42913 wxPyEndAllowThreads(__tstate);
42914 if (PyErr_Occurred()) SWIG_fail;
42915 }
42916 {
42917 wxGBPosition * resultptr;
42918 resultptr = new wxGBPosition((wxGBPosition &)(result));
42919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42920 }
42921 return resultobj;
42922 fail:
42923 return NULL;
42924 }
42925
42926
42927 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42928 PyObject *resultobj;
42929 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42930 wxGridBagSizer *result;
42931 PyObject * obj0 = 0 ;
42932 char *kwnames[] = {
42933 (char *) "self", NULL
42934 };
42935
42936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42938 if (SWIG_arg_fail(1)) SWIG_fail;
42939 {
42940 PyThreadState* __tstate = wxPyBeginAllowThreads();
42941 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42942
42943 wxPyEndAllowThreads(__tstate);
42944 if (PyErr_Occurred()) SWIG_fail;
42945 }
42946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42947 return resultobj;
42948 fail:
42949 return NULL;
42950 }
42951
42952
42953 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42954 PyObject *resultobj;
42955 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42956 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42957 PyObject * obj0 = 0 ;
42958 PyObject * obj1 = 0 ;
42959 char *kwnames[] = {
42960 (char *) "self",(char *) "sizer", NULL
42961 };
42962
42963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42965 if (SWIG_arg_fail(1)) SWIG_fail;
42966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42967 if (SWIG_arg_fail(2)) SWIG_fail;
42968 {
42969 PyThreadState* __tstate = wxPyBeginAllowThreads();
42970 (arg1)->SetGBSizer(arg2);
42971
42972 wxPyEndAllowThreads(__tstate);
42973 if (PyErr_Occurred()) SWIG_fail;
42974 }
42975 Py_INCREF(Py_None); resultobj = Py_None;
42976 return resultobj;
42977 fail:
42978 return NULL;
42979 }
42980
42981
42982 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42983 PyObject *obj;
42984 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42985 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42986 Py_INCREF(obj);
42987 return Py_BuildValue((char *)"");
42988 }
42989 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42990 PyObject *resultobj;
42991 int arg1 = (int) 0 ;
42992 int arg2 = (int) 0 ;
42993 wxGridBagSizer *result;
42994 PyObject * obj0 = 0 ;
42995 PyObject * obj1 = 0 ;
42996 char *kwnames[] = {
42997 (char *) "vgap",(char *) "hgap", NULL
42998 };
42999
43000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43001 if (obj0) {
43002 {
43003 arg1 = (int)(SWIG_As_int(obj0));
43004 if (SWIG_arg_fail(1)) SWIG_fail;
43005 }
43006 }
43007 if (obj1) {
43008 {
43009 arg2 = (int)(SWIG_As_int(obj1));
43010 if (SWIG_arg_fail(2)) SWIG_fail;
43011 }
43012 }
43013 {
43014 PyThreadState* __tstate = wxPyBeginAllowThreads();
43015 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43016
43017 wxPyEndAllowThreads(__tstate);
43018 if (PyErr_Occurred()) SWIG_fail;
43019 }
43020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43021 return resultobj;
43022 fail:
43023 return NULL;
43024 }
43025
43026
43027 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43028 PyObject *resultobj;
43029 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43030 PyObject *arg2 = (PyObject *) 0 ;
43031 wxGBPosition *arg3 = 0 ;
43032 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43033 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43034 int arg5 = (int) 0 ;
43035 int arg6 = (int) 0 ;
43036 PyObject *arg7 = (PyObject *) NULL ;
43037 wxGBSizerItem *result;
43038 wxGBPosition temp3 ;
43039 wxGBSpan temp4 ;
43040 PyObject * obj0 = 0 ;
43041 PyObject * obj1 = 0 ;
43042 PyObject * obj2 = 0 ;
43043 PyObject * obj3 = 0 ;
43044 PyObject * obj4 = 0 ;
43045 PyObject * obj5 = 0 ;
43046 PyObject * obj6 = 0 ;
43047 char *kwnames[] = {
43048 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43049 };
43050
43051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43053 if (SWIG_arg_fail(1)) SWIG_fail;
43054 arg2 = obj1;
43055 {
43056 arg3 = &temp3;
43057 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43058 }
43059 if (obj3) {
43060 {
43061 arg4 = &temp4;
43062 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43063 }
43064 }
43065 if (obj4) {
43066 {
43067 arg5 = (int)(SWIG_As_int(obj4));
43068 if (SWIG_arg_fail(5)) SWIG_fail;
43069 }
43070 }
43071 if (obj5) {
43072 {
43073 arg6 = (int)(SWIG_As_int(obj5));
43074 if (SWIG_arg_fail(6)) SWIG_fail;
43075 }
43076 }
43077 if (obj6) {
43078 arg7 = obj6;
43079 }
43080 {
43081 PyThreadState* __tstate = wxPyBeginAllowThreads();
43082 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43083
43084 wxPyEndAllowThreads(__tstate);
43085 if (PyErr_Occurred()) SWIG_fail;
43086 }
43087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43088 return resultobj;
43089 fail:
43090 return NULL;
43091 }
43092
43093
43094 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43095 PyObject *resultobj;
43096 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43097 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43098 wxGBSizerItem *result;
43099 PyObject * obj0 = 0 ;
43100 PyObject * obj1 = 0 ;
43101 char *kwnames[] = {
43102 (char *) "self",(char *) "item", NULL
43103 };
43104
43105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43107 if (SWIG_arg_fail(1)) SWIG_fail;
43108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43109 if (SWIG_arg_fail(2)) SWIG_fail;
43110 {
43111 PyThreadState* __tstate = wxPyBeginAllowThreads();
43112 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43113
43114 wxPyEndAllowThreads(__tstate);
43115 if (PyErr_Occurred()) SWIG_fail;
43116 }
43117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43118 return resultobj;
43119 fail:
43120 return NULL;
43121 }
43122
43123
43124 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43125 PyObject *resultobj;
43126 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43127 int arg2 ;
43128 int arg3 ;
43129 wxSize result;
43130 PyObject * obj0 = 0 ;
43131 PyObject * obj1 = 0 ;
43132 PyObject * obj2 = 0 ;
43133 char *kwnames[] = {
43134 (char *) "self",(char *) "row",(char *) "col", NULL
43135 };
43136
43137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43139 if (SWIG_arg_fail(1)) SWIG_fail;
43140 {
43141 arg2 = (int)(SWIG_As_int(obj1));
43142 if (SWIG_arg_fail(2)) SWIG_fail;
43143 }
43144 {
43145 arg3 = (int)(SWIG_As_int(obj2));
43146 if (SWIG_arg_fail(3)) SWIG_fail;
43147 }
43148 {
43149 PyThreadState* __tstate = wxPyBeginAllowThreads();
43150 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43151
43152 wxPyEndAllowThreads(__tstate);
43153 if (PyErr_Occurred()) SWIG_fail;
43154 }
43155 {
43156 wxSize * resultptr;
43157 resultptr = new wxSize((wxSize &)(result));
43158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43159 }
43160 return resultobj;
43161 fail:
43162 return NULL;
43163 }
43164
43165
43166 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43167 PyObject *resultobj;
43168 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43169 wxSize result;
43170 PyObject * obj0 = 0 ;
43171 char *kwnames[] = {
43172 (char *) "self", NULL
43173 };
43174
43175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43177 if (SWIG_arg_fail(1)) SWIG_fail;
43178 {
43179 PyThreadState* __tstate = wxPyBeginAllowThreads();
43180 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43181
43182 wxPyEndAllowThreads(__tstate);
43183 if (PyErr_Occurred()) SWIG_fail;
43184 }
43185 {
43186 wxSize * resultptr;
43187 resultptr = new wxSize((wxSize &)(result));
43188 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43189 }
43190 return resultobj;
43191 fail:
43192 return NULL;
43193 }
43194
43195
43196 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43197 PyObject *resultobj;
43198 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43199 wxSize *arg2 = 0 ;
43200 wxSize temp2 ;
43201 PyObject * obj0 = 0 ;
43202 PyObject * obj1 = 0 ;
43203 char *kwnames[] = {
43204 (char *) "self",(char *) "sz", NULL
43205 };
43206
43207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43209 if (SWIG_arg_fail(1)) SWIG_fail;
43210 {
43211 arg2 = &temp2;
43212 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43213 }
43214 {
43215 PyThreadState* __tstate = wxPyBeginAllowThreads();
43216 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43217
43218 wxPyEndAllowThreads(__tstate);
43219 if (PyErr_Occurred()) SWIG_fail;
43220 }
43221 Py_INCREF(Py_None); resultobj = Py_None;
43222 return resultobj;
43223 fail:
43224 return NULL;
43225 }
43226
43227
43228 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43229 PyObject *resultobj;
43230 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43231 wxWindow *arg2 = (wxWindow *) 0 ;
43232 wxGBPosition result;
43233 PyObject * obj0 = 0 ;
43234 PyObject * obj1 = 0 ;
43235
43236 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43238 if (SWIG_arg_fail(1)) SWIG_fail;
43239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43240 if (SWIG_arg_fail(2)) SWIG_fail;
43241 {
43242 PyThreadState* __tstate = wxPyBeginAllowThreads();
43243 result = (arg1)->GetItemPosition(arg2);
43244
43245 wxPyEndAllowThreads(__tstate);
43246 if (PyErr_Occurred()) SWIG_fail;
43247 }
43248 {
43249 wxGBPosition * resultptr;
43250 resultptr = new wxGBPosition((wxGBPosition &)(result));
43251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43252 }
43253 return resultobj;
43254 fail:
43255 return NULL;
43256 }
43257
43258
43259 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43260 PyObject *resultobj;
43261 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43262 wxSizer *arg2 = (wxSizer *) 0 ;
43263 wxGBPosition result;
43264 PyObject * obj0 = 0 ;
43265 PyObject * obj1 = 0 ;
43266
43267 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43269 if (SWIG_arg_fail(1)) SWIG_fail;
43270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43271 if (SWIG_arg_fail(2)) SWIG_fail;
43272 {
43273 PyThreadState* __tstate = wxPyBeginAllowThreads();
43274 result = (arg1)->GetItemPosition(arg2);
43275
43276 wxPyEndAllowThreads(__tstate);
43277 if (PyErr_Occurred()) SWIG_fail;
43278 }
43279 {
43280 wxGBPosition * resultptr;
43281 resultptr = new wxGBPosition((wxGBPosition &)(result));
43282 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43283 }
43284 return resultobj;
43285 fail:
43286 return NULL;
43287 }
43288
43289
43290 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43291 PyObject *resultobj;
43292 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43293 size_t arg2 ;
43294 wxGBPosition result;
43295 PyObject * obj0 = 0 ;
43296 PyObject * obj1 = 0 ;
43297
43298 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43300 if (SWIG_arg_fail(1)) SWIG_fail;
43301 {
43302 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43303 if (SWIG_arg_fail(2)) SWIG_fail;
43304 }
43305 {
43306 PyThreadState* __tstate = wxPyBeginAllowThreads();
43307 result = (arg1)->GetItemPosition(arg2);
43308
43309 wxPyEndAllowThreads(__tstate);
43310 if (PyErr_Occurred()) SWIG_fail;
43311 }
43312 {
43313 wxGBPosition * resultptr;
43314 resultptr = new wxGBPosition((wxGBPosition &)(result));
43315 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43316 }
43317 return resultobj;
43318 fail:
43319 return NULL;
43320 }
43321
43322
43323 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43324 int argc;
43325 PyObject *argv[3];
43326 int ii;
43327
43328 argc = PyObject_Length(args);
43329 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43330 argv[ii] = PyTuple_GetItem(args,ii);
43331 }
43332 if (argc == 2) {
43333 int _v;
43334 {
43335 void *ptr;
43336 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43337 _v = 0;
43338 PyErr_Clear();
43339 } else {
43340 _v = 1;
43341 }
43342 }
43343 if (_v) {
43344 {
43345 void *ptr;
43346 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43347 _v = 0;
43348 PyErr_Clear();
43349 } else {
43350 _v = 1;
43351 }
43352 }
43353 if (_v) {
43354 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43355 }
43356 }
43357 }
43358 if (argc == 2) {
43359 int _v;
43360 {
43361 void *ptr;
43362 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43363 _v = 0;
43364 PyErr_Clear();
43365 } else {
43366 _v = 1;
43367 }
43368 }
43369 if (_v) {
43370 {
43371 void *ptr;
43372 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43373 _v = 0;
43374 PyErr_Clear();
43375 } else {
43376 _v = 1;
43377 }
43378 }
43379 if (_v) {
43380 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43381 }
43382 }
43383 }
43384 if (argc == 2) {
43385 int _v;
43386 {
43387 void *ptr;
43388 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43389 _v = 0;
43390 PyErr_Clear();
43391 } else {
43392 _v = 1;
43393 }
43394 }
43395 if (_v) {
43396 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43397 if (_v) {
43398 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43399 }
43400 }
43401 }
43402
43403 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43404 return NULL;
43405 }
43406
43407
43408 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43409 PyObject *resultobj;
43410 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43411 wxWindow *arg2 = (wxWindow *) 0 ;
43412 wxGBPosition *arg3 = 0 ;
43413 bool result;
43414 wxGBPosition temp3 ;
43415 PyObject * obj0 = 0 ;
43416 PyObject * obj1 = 0 ;
43417 PyObject * obj2 = 0 ;
43418
43419 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43421 if (SWIG_arg_fail(1)) SWIG_fail;
43422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43423 if (SWIG_arg_fail(2)) SWIG_fail;
43424 {
43425 arg3 = &temp3;
43426 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43427 }
43428 {
43429 PyThreadState* __tstate = wxPyBeginAllowThreads();
43430 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43431
43432 wxPyEndAllowThreads(__tstate);
43433 if (PyErr_Occurred()) SWIG_fail;
43434 }
43435 {
43436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43437 }
43438 return resultobj;
43439 fail:
43440 return NULL;
43441 }
43442
43443
43444 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43445 PyObject *resultobj;
43446 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43447 wxSizer *arg2 = (wxSizer *) 0 ;
43448 wxGBPosition *arg3 = 0 ;
43449 bool result;
43450 wxGBPosition temp3 ;
43451 PyObject * obj0 = 0 ;
43452 PyObject * obj1 = 0 ;
43453 PyObject * obj2 = 0 ;
43454
43455 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43457 if (SWIG_arg_fail(1)) SWIG_fail;
43458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43459 if (SWIG_arg_fail(2)) SWIG_fail;
43460 {
43461 arg3 = &temp3;
43462 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43463 }
43464 {
43465 PyThreadState* __tstate = wxPyBeginAllowThreads();
43466 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43467
43468 wxPyEndAllowThreads(__tstate);
43469 if (PyErr_Occurred()) SWIG_fail;
43470 }
43471 {
43472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43473 }
43474 return resultobj;
43475 fail:
43476 return NULL;
43477 }
43478
43479
43480 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43481 PyObject *resultobj;
43482 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43483 size_t arg2 ;
43484 wxGBPosition *arg3 = 0 ;
43485 bool result;
43486 wxGBPosition temp3 ;
43487 PyObject * obj0 = 0 ;
43488 PyObject * obj1 = 0 ;
43489 PyObject * obj2 = 0 ;
43490
43491 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43493 if (SWIG_arg_fail(1)) SWIG_fail;
43494 {
43495 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43496 if (SWIG_arg_fail(2)) SWIG_fail;
43497 }
43498 {
43499 arg3 = &temp3;
43500 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43501 }
43502 {
43503 PyThreadState* __tstate = wxPyBeginAllowThreads();
43504 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43505
43506 wxPyEndAllowThreads(__tstate);
43507 if (PyErr_Occurred()) SWIG_fail;
43508 }
43509 {
43510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43511 }
43512 return resultobj;
43513 fail:
43514 return NULL;
43515 }
43516
43517
43518 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43519 int argc;
43520 PyObject *argv[4];
43521 int ii;
43522
43523 argc = PyObject_Length(args);
43524 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43525 argv[ii] = PyTuple_GetItem(args,ii);
43526 }
43527 if (argc == 3) {
43528 int _v;
43529 {
43530 void *ptr;
43531 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43532 _v = 0;
43533 PyErr_Clear();
43534 } else {
43535 _v = 1;
43536 }
43537 }
43538 if (_v) {
43539 {
43540 void *ptr;
43541 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43542 _v = 0;
43543 PyErr_Clear();
43544 } else {
43545 _v = 1;
43546 }
43547 }
43548 if (_v) {
43549 {
43550 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43551 }
43552 if (_v) {
43553 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43554 }
43555 }
43556 }
43557 }
43558 if (argc == 3) {
43559 int _v;
43560 {
43561 void *ptr;
43562 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43563 _v = 0;
43564 PyErr_Clear();
43565 } else {
43566 _v = 1;
43567 }
43568 }
43569 if (_v) {
43570 {
43571 void *ptr;
43572 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43573 _v = 0;
43574 PyErr_Clear();
43575 } else {
43576 _v = 1;
43577 }
43578 }
43579 if (_v) {
43580 {
43581 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43582 }
43583 if (_v) {
43584 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43585 }
43586 }
43587 }
43588 }
43589 if (argc == 3) {
43590 int _v;
43591 {
43592 void *ptr;
43593 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43594 _v = 0;
43595 PyErr_Clear();
43596 } else {
43597 _v = 1;
43598 }
43599 }
43600 if (_v) {
43601 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43602 if (_v) {
43603 {
43604 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43605 }
43606 if (_v) {
43607 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43608 }
43609 }
43610 }
43611 }
43612
43613 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43614 return NULL;
43615 }
43616
43617
43618 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43619 PyObject *resultobj;
43620 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43621 wxWindow *arg2 = (wxWindow *) 0 ;
43622 wxGBSpan result;
43623 PyObject * obj0 = 0 ;
43624 PyObject * obj1 = 0 ;
43625
43626 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43628 if (SWIG_arg_fail(1)) SWIG_fail;
43629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43630 if (SWIG_arg_fail(2)) SWIG_fail;
43631 {
43632 PyThreadState* __tstate = wxPyBeginAllowThreads();
43633 result = (arg1)->GetItemSpan(arg2);
43634
43635 wxPyEndAllowThreads(__tstate);
43636 if (PyErr_Occurred()) SWIG_fail;
43637 }
43638 {
43639 wxGBSpan * resultptr;
43640 resultptr = new wxGBSpan((wxGBSpan &)(result));
43641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43642 }
43643 return resultobj;
43644 fail:
43645 return NULL;
43646 }
43647
43648
43649 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43650 PyObject *resultobj;
43651 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43652 wxSizer *arg2 = (wxSizer *) 0 ;
43653 wxGBSpan result;
43654 PyObject * obj0 = 0 ;
43655 PyObject * obj1 = 0 ;
43656
43657 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43659 if (SWIG_arg_fail(1)) SWIG_fail;
43660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43661 if (SWIG_arg_fail(2)) SWIG_fail;
43662 {
43663 PyThreadState* __tstate = wxPyBeginAllowThreads();
43664 result = (arg1)->GetItemSpan(arg2);
43665
43666 wxPyEndAllowThreads(__tstate);
43667 if (PyErr_Occurred()) SWIG_fail;
43668 }
43669 {
43670 wxGBSpan * resultptr;
43671 resultptr = new wxGBSpan((wxGBSpan &)(result));
43672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43673 }
43674 return resultobj;
43675 fail:
43676 return NULL;
43677 }
43678
43679
43680 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43681 PyObject *resultobj;
43682 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43683 size_t arg2 ;
43684 wxGBSpan result;
43685 PyObject * obj0 = 0 ;
43686 PyObject * obj1 = 0 ;
43687
43688 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43690 if (SWIG_arg_fail(1)) SWIG_fail;
43691 {
43692 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43693 if (SWIG_arg_fail(2)) SWIG_fail;
43694 }
43695 {
43696 PyThreadState* __tstate = wxPyBeginAllowThreads();
43697 result = (arg1)->GetItemSpan(arg2);
43698
43699 wxPyEndAllowThreads(__tstate);
43700 if (PyErr_Occurred()) SWIG_fail;
43701 }
43702 {
43703 wxGBSpan * resultptr;
43704 resultptr = new wxGBSpan((wxGBSpan &)(result));
43705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43706 }
43707 return resultobj;
43708 fail:
43709 return NULL;
43710 }
43711
43712
43713 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43714 int argc;
43715 PyObject *argv[3];
43716 int ii;
43717
43718 argc = PyObject_Length(args);
43719 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43720 argv[ii] = PyTuple_GetItem(args,ii);
43721 }
43722 if (argc == 2) {
43723 int _v;
43724 {
43725 void *ptr;
43726 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43727 _v = 0;
43728 PyErr_Clear();
43729 } else {
43730 _v = 1;
43731 }
43732 }
43733 if (_v) {
43734 {
43735 void *ptr;
43736 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43737 _v = 0;
43738 PyErr_Clear();
43739 } else {
43740 _v = 1;
43741 }
43742 }
43743 if (_v) {
43744 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43745 }
43746 }
43747 }
43748 if (argc == 2) {
43749 int _v;
43750 {
43751 void *ptr;
43752 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43753 _v = 0;
43754 PyErr_Clear();
43755 } else {
43756 _v = 1;
43757 }
43758 }
43759 if (_v) {
43760 {
43761 void *ptr;
43762 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43763 _v = 0;
43764 PyErr_Clear();
43765 } else {
43766 _v = 1;
43767 }
43768 }
43769 if (_v) {
43770 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43771 }
43772 }
43773 }
43774 if (argc == 2) {
43775 int _v;
43776 {
43777 void *ptr;
43778 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43779 _v = 0;
43780 PyErr_Clear();
43781 } else {
43782 _v = 1;
43783 }
43784 }
43785 if (_v) {
43786 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43787 if (_v) {
43788 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43789 }
43790 }
43791 }
43792
43793 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43794 return NULL;
43795 }
43796
43797
43798 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43799 PyObject *resultobj;
43800 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43801 wxWindow *arg2 = (wxWindow *) 0 ;
43802 wxGBSpan *arg3 = 0 ;
43803 bool result;
43804 wxGBSpan temp3 ;
43805 PyObject * obj0 = 0 ;
43806 PyObject * obj1 = 0 ;
43807 PyObject * obj2 = 0 ;
43808
43809 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43811 if (SWIG_arg_fail(1)) SWIG_fail;
43812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43813 if (SWIG_arg_fail(2)) SWIG_fail;
43814 {
43815 arg3 = &temp3;
43816 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43817 }
43818 {
43819 PyThreadState* __tstate = wxPyBeginAllowThreads();
43820 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43821
43822 wxPyEndAllowThreads(__tstate);
43823 if (PyErr_Occurred()) SWIG_fail;
43824 }
43825 {
43826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43827 }
43828 return resultobj;
43829 fail:
43830 return NULL;
43831 }
43832
43833
43834 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43835 PyObject *resultobj;
43836 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43837 wxSizer *arg2 = (wxSizer *) 0 ;
43838 wxGBSpan *arg3 = 0 ;
43839 bool result;
43840 wxGBSpan temp3 ;
43841 PyObject * obj0 = 0 ;
43842 PyObject * obj1 = 0 ;
43843 PyObject * obj2 = 0 ;
43844
43845 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43847 if (SWIG_arg_fail(1)) SWIG_fail;
43848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43849 if (SWIG_arg_fail(2)) SWIG_fail;
43850 {
43851 arg3 = &temp3;
43852 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43853 }
43854 {
43855 PyThreadState* __tstate = wxPyBeginAllowThreads();
43856 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43857
43858 wxPyEndAllowThreads(__tstate);
43859 if (PyErr_Occurred()) SWIG_fail;
43860 }
43861 {
43862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43863 }
43864 return resultobj;
43865 fail:
43866 return NULL;
43867 }
43868
43869
43870 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43871 PyObject *resultobj;
43872 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43873 size_t arg2 ;
43874 wxGBSpan *arg3 = 0 ;
43875 bool result;
43876 wxGBSpan temp3 ;
43877 PyObject * obj0 = 0 ;
43878 PyObject * obj1 = 0 ;
43879 PyObject * obj2 = 0 ;
43880
43881 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43883 if (SWIG_arg_fail(1)) SWIG_fail;
43884 {
43885 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43886 if (SWIG_arg_fail(2)) SWIG_fail;
43887 }
43888 {
43889 arg3 = &temp3;
43890 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43891 }
43892 {
43893 PyThreadState* __tstate = wxPyBeginAllowThreads();
43894 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43895
43896 wxPyEndAllowThreads(__tstate);
43897 if (PyErr_Occurred()) SWIG_fail;
43898 }
43899 {
43900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43901 }
43902 return resultobj;
43903 fail:
43904 return NULL;
43905 }
43906
43907
43908 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43909 int argc;
43910 PyObject *argv[4];
43911 int ii;
43912
43913 argc = PyObject_Length(args);
43914 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43915 argv[ii] = PyTuple_GetItem(args,ii);
43916 }
43917 if (argc == 3) {
43918 int _v;
43919 {
43920 void *ptr;
43921 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43922 _v = 0;
43923 PyErr_Clear();
43924 } else {
43925 _v = 1;
43926 }
43927 }
43928 if (_v) {
43929 {
43930 void *ptr;
43931 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43932 _v = 0;
43933 PyErr_Clear();
43934 } else {
43935 _v = 1;
43936 }
43937 }
43938 if (_v) {
43939 {
43940 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43941 }
43942 if (_v) {
43943 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43944 }
43945 }
43946 }
43947 }
43948 if (argc == 3) {
43949 int _v;
43950 {
43951 void *ptr;
43952 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43953 _v = 0;
43954 PyErr_Clear();
43955 } else {
43956 _v = 1;
43957 }
43958 }
43959 if (_v) {
43960 {
43961 void *ptr;
43962 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43963 _v = 0;
43964 PyErr_Clear();
43965 } else {
43966 _v = 1;
43967 }
43968 }
43969 if (_v) {
43970 {
43971 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43972 }
43973 if (_v) {
43974 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43975 }
43976 }
43977 }
43978 }
43979 if (argc == 3) {
43980 int _v;
43981 {
43982 void *ptr;
43983 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43984 _v = 0;
43985 PyErr_Clear();
43986 } else {
43987 _v = 1;
43988 }
43989 }
43990 if (_v) {
43991 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43992 if (_v) {
43993 {
43994 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43995 }
43996 if (_v) {
43997 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43998 }
43999 }
44000 }
44001 }
44002
44003 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44004 return NULL;
44005 }
44006
44007
44008 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44009 PyObject *resultobj;
44010 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44011 wxWindow *arg2 = (wxWindow *) 0 ;
44012 wxGBSizerItem *result;
44013 PyObject * obj0 = 0 ;
44014 PyObject * obj1 = 0 ;
44015
44016 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44018 if (SWIG_arg_fail(1)) SWIG_fail;
44019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44020 if (SWIG_arg_fail(2)) SWIG_fail;
44021 {
44022 PyThreadState* __tstate = wxPyBeginAllowThreads();
44023 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44024
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44029 return resultobj;
44030 fail:
44031 return NULL;
44032 }
44033
44034
44035 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44036 PyObject *resultobj;
44037 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44038 wxSizer *arg2 = (wxSizer *) 0 ;
44039 wxGBSizerItem *result;
44040 PyObject * obj0 = 0 ;
44041 PyObject * obj1 = 0 ;
44042
44043 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44045 if (SWIG_arg_fail(1)) SWIG_fail;
44046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44047 if (SWIG_arg_fail(2)) SWIG_fail;
44048 {
44049 PyThreadState* __tstate = wxPyBeginAllowThreads();
44050 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44051
44052 wxPyEndAllowThreads(__tstate);
44053 if (PyErr_Occurred()) SWIG_fail;
44054 }
44055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44056 return resultobj;
44057 fail:
44058 return NULL;
44059 }
44060
44061
44062 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44063 int argc;
44064 PyObject *argv[3];
44065 int ii;
44066
44067 argc = PyObject_Length(args);
44068 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44069 argv[ii] = PyTuple_GetItem(args,ii);
44070 }
44071 if (argc == 2) {
44072 int _v;
44073 {
44074 void *ptr;
44075 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44076 _v = 0;
44077 PyErr_Clear();
44078 } else {
44079 _v = 1;
44080 }
44081 }
44082 if (_v) {
44083 {
44084 void *ptr;
44085 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44086 _v = 0;
44087 PyErr_Clear();
44088 } else {
44089 _v = 1;
44090 }
44091 }
44092 if (_v) {
44093 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44094 }
44095 }
44096 }
44097 if (argc == 2) {
44098 int _v;
44099 {
44100 void *ptr;
44101 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44102 _v = 0;
44103 PyErr_Clear();
44104 } else {
44105 _v = 1;
44106 }
44107 }
44108 if (_v) {
44109 {
44110 void *ptr;
44111 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44112 _v = 0;
44113 PyErr_Clear();
44114 } else {
44115 _v = 1;
44116 }
44117 }
44118 if (_v) {
44119 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44120 }
44121 }
44122 }
44123
44124 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44125 return NULL;
44126 }
44127
44128
44129 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44130 PyObject *resultobj;
44131 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44132 wxGBPosition *arg2 = 0 ;
44133 wxGBSizerItem *result;
44134 wxGBPosition temp2 ;
44135 PyObject * obj0 = 0 ;
44136 PyObject * obj1 = 0 ;
44137 char *kwnames[] = {
44138 (char *) "self",(char *) "pos", NULL
44139 };
44140
44141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44143 if (SWIG_arg_fail(1)) SWIG_fail;
44144 {
44145 arg2 = &temp2;
44146 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44147 }
44148 {
44149 PyThreadState* __tstate = wxPyBeginAllowThreads();
44150 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44151
44152 wxPyEndAllowThreads(__tstate);
44153 if (PyErr_Occurred()) SWIG_fail;
44154 }
44155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44156 return resultobj;
44157 fail:
44158 return NULL;
44159 }
44160
44161
44162 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44163 PyObject *resultobj;
44164 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44165 wxPoint *arg2 = 0 ;
44166 wxGBSizerItem *result;
44167 wxPoint temp2 ;
44168 PyObject * obj0 = 0 ;
44169 PyObject * obj1 = 0 ;
44170 char *kwnames[] = {
44171 (char *) "self",(char *) "pt", NULL
44172 };
44173
44174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44176 if (SWIG_arg_fail(1)) SWIG_fail;
44177 {
44178 arg2 = &temp2;
44179 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44180 }
44181 {
44182 PyThreadState* __tstate = wxPyBeginAllowThreads();
44183 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44184
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44189 return resultobj;
44190 fail:
44191 return NULL;
44192 }
44193
44194
44195 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44196 PyObject *resultobj;
44197 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44198 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44199 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44200 bool result;
44201 PyObject * obj0 = 0 ;
44202 PyObject * obj1 = 0 ;
44203 PyObject * obj2 = 0 ;
44204 char *kwnames[] = {
44205 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44206 };
44207
44208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44210 if (SWIG_arg_fail(1)) SWIG_fail;
44211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44212 if (SWIG_arg_fail(2)) SWIG_fail;
44213 if (obj2) {
44214 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44215 if (SWIG_arg_fail(3)) SWIG_fail;
44216 }
44217 {
44218 PyThreadState* __tstate = wxPyBeginAllowThreads();
44219 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44220
44221 wxPyEndAllowThreads(__tstate);
44222 if (PyErr_Occurred()) SWIG_fail;
44223 }
44224 {
44225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44226 }
44227 return resultobj;
44228 fail:
44229 return NULL;
44230 }
44231
44232
44233 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44234 PyObject *resultobj;
44235 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44236 wxGBPosition *arg2 = 0 ;
44237 wxGBSpan *arg3 = 0 ;
44238 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44239 bool result;
44240 wxGBPosition temp2 ;
44241 wxGBSpan temp3 ;
44242 PyObject * obj0 = 0 ;
44243 PyObject * obj1 = 0 ;
44244 PyObject * obj2 = 0 ;
44245 PyObject * obj3 = 0 ;
44246 char *kwnames[] = {
44247 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44248 };
44249
44250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44252 if (SWIG_arg_fail(1)) SWIG_fail;
44253 {
44254 arg2 = &temp2;
44255 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44256 }
44257 {
44258 arg3 = &temp3;
44259 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44260 }
44261 if (obj3) {
44262 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44263 if (SWIG_arg_fail(4)) SWIG_fail;
44264 }
44265 {
44266 PyThreadState* __tstate = wxPyBeginAllowThreads();
44267 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44268
44269 wxPyEndAllowThreads(__tstate);
44270 if (PyErr_Occurred()) SWIG_fail;
44271 }
44272 {
44273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44274 }
44275 return resultobj;
44276 fail:
44277 return NULL;
44278 }
44279
44280
44281 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44282 PyObject *obj;
44283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44284 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44285 Py_INCREF(obj);
44286 return Py_BuildValue((char *)"");
44287 }
44288 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44289 PyObject *resultobj;
44290 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44291 wxRelationship arg2 ;
44292 wxWindow *arg3 = (wxWindow *) 0 ;
44293 wxEdge arg4 ;
44294 int arg5 = (int) 0 ;
44295 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44296 PyObject * obj0 = 0 ;
44297 PyObject * obj1 = 0 ;
44298 PyObject * obj2 = 0 ;
44299 PyObject * obj3 = 0 ;
44300 PyObject * obj4 = 0 ;
44301 PyObject * obj5 = 0 ;
44302 char *kwnames[] = {
44303 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44304 };
44305
44306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44308 if (SWIG_arg_fail(1)) SWIG_fail;
44309 {
44310 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44311 if (SWIG_arg_fail(2)) SWIG_fail;
44312 }
44313 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44314 if (SWIG_arg_fail(3)) SWIG_fail;
44315 {
44316 arg4 = (wxEdge)(SWIG_As_int(obj3));
44317 if (SWIG_arg_fail(4)) SWIG_fail;
44318 }
44319 if (obj4) {
44320 {
44321 arg5 = (int)(SWIG_As_int(obj4));
44322 if (SWIG_arg_fail(5)) SWIG_fail;
44323 }
44324 }
44325 if (obj5) {
44326 {
44327 arg6 = (int)(SWIG_As_int(obj5));
44328 if (SWIG_arg_fail(6)) SWIG_fail;
44329 }
44330 }
44331 {
44332 PyThreadState* __tstate = wxPyBeginAllowThreads();
44333 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44334
44335 wxPyEndAllowThreads(__tstate);
44336 if (PyErr_Occurred()) SWIG_fail;
44337 }
44338 Py_INCREF(Py_None); resultobj = Py_None;
44339 return resultobj;
44340 fail:
44341 return NULL;
44342 }
44343
44344
44345 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44346 PyObject *resultobj;
44347 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44348 wxWindow *arg2 = (wxWindow *) 0 ;
44349 int arg3 = (int) 0 ;
44350 PyObject * obj0 = 0 ;
44351 PyObject * obj1 = 0 ;
44352 PyObject * obj2 = 0 ;
44353 char *kwnames[] = {
44354 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44355 };
44356
44357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44359 if (SWIG_arg_fail(1)) SWIG_fail;
44360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44361 if (SWIG_arg_fail(2)) SWIG_fail;
44362 if (obj2) {
44363 {
44364 arg3 = (int)(SWIG_As_int(obj2));
44365 if (SWIG_arg_fail(3)) SWIG_fail;
44366 }
44367 }
44368 {
44369 PyThreadState* __tstate = wxPyBeginAllowThreads();
44370 (arg1)->LeftOf(arg2,arg3);
44371
44372 wxPyEndAllowThreads(__tstate);
44373 if (PyErr_Occurred()) SWIG_fail;
44374 }
44375 Py_INCREF(Py_None); resultobj = Py_None;
44376 return resultobj;
44377 fail:
44378 return NULL;
44379 }
44380
44381
44382 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44383 PyObject *resultobj;
44384 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44385 wxWindow *arg2 = (wxWindow *) 0 ;
44386 int arg3 = (int) 0 ;
44387 PyObject * obj0 = 0 ;
44388 PyObject * obj1 = 0 ;
44389 PyObject * obj2 = 0 ;
44390 char *kwnames[] = {
44391 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44392 };
44393
44394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44396 if (SWIG_arg_fail(1)) SWIG_fail;
44397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44398 if (SWIG_arg_fail(2)) SWIG_fail;
44399 if (obj2) {
44400 {
44401 arg3 = (int)(SWIG_As_int(obj2));
44402 if (SWIG_arg_fail(3)) SWIG_fail;
44403 }
44404 }
44405 {
44406 PyThreadState* __tstate = wxPyBeginAllowThreads();
44407 (arg1)->RightOf(arg2,arg3);
44408
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 Py_INCREF(Py_None); resultobj = Py_None;
44413 return resultobj;
44414 fail:
44415 return NULL;
44416 }
44417
44418
44419 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44420 PyObject *resultobj;
44421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44422 wxWindow *arg2 = (wxWindow *) 0 ;
44423 int arg3 = (int) 0 ;
44424 PyObject * obj0 = 0 ;
44425 PyObject * obj1 = 0 ;
44426 PyObject * obj2 = 0 ;
44427 char *kwnames[] = {
44428 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44429 };
44430
44431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44433 if (SWIG_arg_fail(1)) SWIG_fail;
44434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44435 if (SWIG_arg_fail(2)) SWIG_fail;
44436 if (obj2) {
44437 {
44438 arg3 = (int)(SWIG_As_int(obj2));
44439 if (SWIG_arg_fail(3)) SWIG_fail;
44440 }
44441 }
44442 {
44443 PyThreadState* __tstate = wxPyBeginAllowThreads();
44444 (arg1)->Above(arg2,arg3);
44445
44446 wxPyEndAllowThreads(__tstate);
44447 if (PyErr_Occurred()) SWIG_fail;
44448 }
44449 Py_INCREF(Py_None); resultobj = Py_None;
44450 return resultobj;
44451 fail:
44452 return NULL;
44453 }
44454
44455
44456 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44457 PyObject *resultobj;
44458 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44459 wxWindow *arg2 = (wxWindow *) 0 ;
44460 int arg3 = (int) 0 ;
44461 PyObject * obj0 = 0 ;
44462 PyObject * obj1 = 0 ;
44463 PyObject * obj2 = 0 ;
44464 char *kwnames[] = {
44465 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44466 };
44467
44468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44470 if (SWIG_arg_fail(1)) SWIG_fail;
44471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44472 if (SWIG_arg_fail(2)) SWIG_fail;
44473 if (obj2) {
44474 {
44475 arg3 = (int)(SWIG_As_int(obj2));
44476 if (SWIG_arg_fail(3)) SWIG_fail;
44477 }
44478 }
44479 {
44480 PyThreadState* __tstate = wxPyBeginAllowThreads();
44481 (arg1)->Below(arg2,arg3);
44482
44483 wxPyEndAllowThreads(__tstate);
44484 if (PyErr_Occurred()) SWIG_fail;
44485 }
44486 Py_INCREF(Py_None); resultobj = Py_None;
44487 return resultobj;
44488 fail:
44489 return NULL;
44490 }
44491
44492
44493 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44494 PyObject *resultobj;
44495 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44496 wxWindow *arg2 = (wxWindow *) 0 ;
44497 wxEdge arg3 ;
44498 int arg4 = (int) 0 ;
44499 PyObject * obj0 = 0 ;
44500 PyObject * obj1 = 0 ;
44501 PyObject * obj2 = 0 ;
44502 PyObject * obj3 = 0 ;
44503 char *kwnames[] = {
44504 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44505 };
44506
44507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44509 if (SWIG_arg_fail(1)) SWIG_fail;
44510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44511 if (SWIG_arg_fail(2)) SWIG_fail;
44512 {
44513 arg3 = (wxEdge)(SWIG_As_int(obj2));
44514 if (SWIG_arg_fail(3)) SWIG_fail;
44515 }
44516 if (obj3) {
44517 {
44518 arg4 = (int)(SWIG_As_int(obj3));
44519 if (SWIG_arg_fail(4)) SWIG_fail;
44520 }
44521 }
44522 {
44523 PyThreadState* __tstate = wxPyBeginAllowThreads();
44524 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44525
44526 wxPyEndAllowThreads(__tstate);
44527 if (PyErr_Occurred()) SWIG_fail;
44528 }
44529 Py_INCREF(Py_None); resultobj = Py_None;
44530 return resultobj;
44531 fail:
44532 return NULL;
44533 }
44534
44535
44536 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44537 PyObject *resultobj;
44538 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44539 wxWindow *arg2 = (wxWindow *) 0 ;
44540 wxEdge arg3 ;
44541 int arg4 ;
44542 PyObject * obj0 = 0 ;
44543 PyObject * obj1 = 0 ;
44544 PyObject * obj2 = 0 ;
44545 PyObject * obj3 = 0 ;
44546 char *kwnames[] = {
44547 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44548 };
44549
44550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44552 if (SWIG_arg_fail(1)) SWIG_fail;
44553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44554 if (SWIG_arg_fail(2)) SWIG_fail;
44555 {
44556 arg3 = (wxEdge)(SWIG_As_int(obj2));
44557 if (SWIG_arg_fail(3)) SWIG_fail;
44558 }
44559 {
44560 arg4 = (int)(SWIG_As_int(obj3));
44561 if (SWIG_arg_fail(4)) SWIG_fail;
44562 }
44563 {
44564 PyThreadState* __tstate = wxPyBeginAllowThreads();
44565 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44566
44567 wxPyEndAllowThreads(__tstate);
44568 if (PyErr_Occurred()) SWIG_fail;
44569 }
44570 Py_INCREF(Py_None); resultobj = Py_None;
44571 return resultobj;
44572 fail:
44573 return NULL;
44574 }
44575
44576
44577 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44578 PyObject *resultobj;
44579 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44580 int arg2 ;
44581 PyObject * obj0 = 0 ;
44582 PyObject * obj1 = 0 ;
44583 char *kwnames[] = {
44584 (char *) "self",(char *) "val", NULL
44585 };
44586
44587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44589 if (SWIG_arg_fail(1)) SWIG_fail;
44590 {
44591 arg2 = (int)(SWIG_As_int(obj1));
44592 if (SWIG_arg_fail(2)) SWIG_fail;
44593 }
44594 {
44595 PyThreadState* __tstate = wxPyBeginAllowThreads();
44596 (arg1)->Absolute(arg2);
44597
44598 wxPyEndAllowThreads(__tstate);
44599 if (PyErr_Occurred()) SWIG_fail;
44600 }
44601 Py_INCREF(Py_None); resultobj = Py_None;
44602 return resultobj;
44603 fail:
44604 return NULL;
44605 }
44606
44607
44608 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44609 PyObject *resultobj;
44610 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44611 PyObject * obj0 = 0 ;
44612 char *kwnames[] = {
44613 (char *) "self", NULL
44614 };
44615
44616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44618 if (SWIG_arg_fail(1)) SWIG_fail;
44619 {
44620 PyThreadState* __tstate = wxPyBeginAllowThreads();
44621 (arg1)->Unconstrained();
44622
44623 wxPyEndAllowThreads(__tstate);
44624 if (PyErr_Occurred()) SWIG_fail;
44625 }
44626 Py_INCREF(Py_None); resultobj = Py_None;
44627 return resultobj;
44628 fail:
44629 return NULL;
44630 }
44631
44632
44633 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44634 PyObject *resultobj;
44635 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44636 PyObject * obj0 = 0 ;
44637 char *kwnames[] = {
44638 (char *) "self", NULL
44639 };
44640
44641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44643 if (SWIG_arg_fail(1)) SWIG_fail;
44644 {
44645 PyThreadState* __tstate = wxPyBeginAllowThreads();
44646 (arg1)->AsIs();
44647
44648 wxPyEndAllowThreads(__tstate);
44649 if (PyErr_Occurred()) SWIG_fail;
44650 }
44651 Py_INCREF(Py_None); resultobj = Py_None;
44652 return resultobj;
44653 fail:
44654 return NULL;
44655 }
44656
44657
44658 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44659 PyObject *resultobj;
44660 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44661 wxWindow *result;
44662 PyObject * obj0 = 0 ;
44663 char *kwnames[] = {
44664 (char *) "self", NULL
44665 };
44666
44667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44669 if (SWIG_arg_fail(1)) SWIG_fail;
44670 {
44671 PyThreadState* __tstate = wxPyBeginAllowThreads();
44672 result = (wxWindow *)(arg1)->GetOtherWindow();
44673
44674 wxPyEndAllowThreads(__tstate);
44675 if (PyErr_Occurred()) SWIG_fail;
44676 }
44677 {
44678 resultobj = wxPyMake_wxObject(result, 0);
44679 }
44680 return resultobj;
44681 fail:
44682 return NULL;
44683 }
44684
44685
44686 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44687 PyObject *resultobj;
44688 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44689 wxEdge result;
44690 PyObject * obj0 = 0 ;
44691 char *kwnames[] = {
44692 (char *) "self", NULL
44693 };
44694
44695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44697 if (SWIG_arg_fail(1)) SWIG_fail;
44698 {
44699 PyThreadState* __tstate = wxPyBeginAllowThreads();
44700 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44701
44702 wxPyEndAllowThreads(__tstate);
44703 if (PyErr_Occurred()) SWIG_fail;
44704 }
44705 resultobj = SWIG_From_int((result));
44706 return resultobj;
44707 fail:
44708 return NULL;
44709 }
44710
44711
44712 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44713 PyObject *resultobj;
44714 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44715 wxEdge arg2 ;
44716 PyObject * obj0 = 0 ;
44717 PyObject * obj1 = 0 ;
44718 char *kwnames[] = {
44719 (char *) "self",(char *) "which", NULL
44720 };
44721
44722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44724 if (SWIG_arg_fail(1)) SWIG_fail;
44725 {
44726 arg2 = (wxEdge)(SWIG_As_int(obj1));
44727 if (SWIG_arg_fail(2)) SWIG_fail;
44728 }
44729 {
44730 PyThreadState* __tstate = wxPyBeginAllowThreads();
44731 (arg1)->SetEdge((wxEdge )arg2);
44732
44733 wxPyEndAllowThreads(__tstate);
44734 if (PyErr_Occurred()) SWIG_fail;
44735 }
44736 Py_INCREF(Py_None); resultobj = Py_None;
44737 return resultobj;
44738 fail:
44739 return NULL;
44740 }
44741
44742
44743 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44744 PyObject *resultobj;
44745 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44746 int arg2 ;
44747 PyObject * obj0 = 0 ;
44748 PyObject * obj1 = 0 ;
44749 char *kwnames[] = {
44750 (char *) "self",(char *) "v", NULL
44751 };
44752
44753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44755 if (SWIG_arg_fail(1)) SWIG_fail;
44756 {
44757 arg2 = (int)(SWIG_As_int(obj1));
44758 if (SWIG_arg_fail(2)) SWIG_fail;
44759 }
44760 {
44761 PyThreadState* __tstate = wxPyBeginAllowThreads();
44762 (arg1)->SetValue(arg2);
44763
44764 wxPyEndAllowThreads(__tstate);
44765 if (PyErr_Occurred()) SWIG_fail;
44766 }
44767 Py_INCREF(Py_None); resultobj = Py_None;
44768 return resultobj;
44769 fail:
44770 return NULL;
44771 }
44772
44773
44774 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44775 PyObject *resultobj;
44776 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44777 int result;
44778 PyObject * obj0 = 0 ;
44779 char *kwnames[] = {
44780 (char *) "self", NULL
44781 };
44782
44783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44785 if (SWIG_arg_fail(1)) SWIG_fail;
44786 {
44787 PyThreadState* __tstate = wxPyBeginAllowThreads();
44788 result = (int)(arg1)->GetMargin();
44789
44790 wxPyEndAllowThreads(__tstate);
44791 if (PyErr_Occurred()) SWIG_fail;
44792 }
44793 {
44794 resultobj = SWIG_From_int((int)(result));
44795 }
44796 return resultobj;
44797 fail:
44798 return NULL;
44799 }
44800
44801
44802 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44803 PyObject *resultobj;
44804 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44805 int arg2 ;
44806 PyObject * obj0 = 0 ;
44807 PyObject * obj1 = 0 ;
44808 char *kwnames[] = {
44809 (char *) "self",(char *) "m", NULL
44810 };
44811
44812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44814 if (SWIG_arg_fail(1)) SWIG_fail;
44815 {
44816 arg2 = (int)(SWIG_As_int(obj1));
44817 if (SWIG_arg_fail(2)) SWIG_fail;
44818 }
44819 {
44820 PyThreadState* __tstate = wxPyBeginAllowThreads();
44821 (arg1)->SetMargin(arg2);
44822
44823 wxPyEndAllowThreads(__tstate);
44824 if (PyErr_Occurred()) SWIG_fail;
44825 }
44826 Py_INCREF(Py_None); resultobj = Py_None;
44827 return resultobj;
44828 fail:
44829 return NULL;
44830 }
44831
44832
44833 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44834 PyObject *resultobj;
44835 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44836 int result;
44837 PyObject * obj0 = 0 ;
44838 char *kwnames[] = {
44839 (char *) "self", NULL
44840 };
44841
44842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44844 if (SWIG_arg_fail(1)) SWIG_fail;
44845 {
44846 PyThreadState* __tstate = wxPyBeginAllowThreads();
44847 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44848
44849 wxPyEndAllowThreads(__tstate);
44850 if (PyErr_Occurred()) SWIG_fail;
44851 }
44852 {
44853 resultobj = SWIG_From_int((int)(result));
44854 }
44855 return resultobj;
44856 fail:
44857 return NULL;
44858 }
44859
44860
44861 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44862 PyObject *resultobj;
44863 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44864 int result;
44865 PyObject * obj0 = 0 ;
44866 char *kwnames[] = {
44867 (char *) "self", NULL
44868 };
44869
44870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44872 if (SWIG_arg_fail(1)) SWIG_fail;
44873 {
44874 PyThreadState* __tstate = wxPyBeginAllowThreads();
44875 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44876
44877 wxPyEndAllowThreads(__tstate);
44878 if (PyErr_Occurred()) SWIG_fail;
44879 }
44880 {
44881 resultobj = SWIG_From_int((int)(result));
44882 }
44883 return resultobj;
44884 fail:
44885 return NULL;
44886 }
44887
44888
44889 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44890 PyObject *resultobj;
44891 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44892 int result;
44893 PyObject * obj0 = 0 ;
44894 char *kwnames[] = {
44895 (char *) "self", NULL
44896 };
44897
44898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44900 if (SWIG_arg_fail(1)) SWIG_fail;
44901 {
44902 PyThreadState* __tstate = wxPyBeginAllowThreads();
44903 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44904
44905 wxPyEndAllowThreads(__tstate);
44906 if (PyErr_Occurred()) SWIG_fail;
44907 }
44908 {
44909 resultobj = SWIG_From_int((int)(result));
44910 }
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44918 PyObject *resultobj;
44919 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44920 bool result;
44921 PyObject * obj0 = 0 ;
44922 char *kwnames[] = {
44923 (char *) "self", NULL
44924 };
44925
44926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44928 if (SWIG_arg_fail(1)) SWIG_fail;
44929 {
44930 PyThreadState* __tstate = wxPyBeginAllowThreads();
44931 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44932
44933 wxPyEndAllowThreads(__tstate);
44934 if (PyErr_Occurred()) SWIG_fail;
44935 }
44936 {
44937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44938 }
44939 return resultobj;
44940 fail:
44941 return NULL;
44942 }
44943
44944
44945 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44946 PyObject *resultobj;
44947 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44948 bool arg2 ;
44949 PyObject * obj0 = 0 ;
44950 PyObject * obj1 = 0 ;
44951 char *kwnames[] = {
44952 (char *) "self",(char *) "d", NULL
44953 };
44954
44955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44957 if (SWIG_arg_fail(1)) SWIG_fail;
44958 {
44959 arg2 = (bool)(SWIG_As_bool(obj1));
44960 if (SWIG_arg_fail(2)) SWIG_fail;
44961 }
44962 {
44963 PyThreadState* __tstate = wxPyBeginAllowThreads();
44964 (arg1)->SetDone(arg2);
44965
44966 wxPyEndAllowThreads(__tstate);
44967 if (PyErr_Occurred()) SWIG_fail;
44968 }
44969 Py_INCREF(Py_None); resultobj = Py_None;
44970 return resultobj;
44971 fail:
44972 return NULL;
44973 }
44974
44975
44976 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44977 PyObject *resultobj;
44978 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44979 wxRelationship result;
44980 PyObject * obj0 = 0 ;
44981 char *kwnames[] = {
44982 (char *) "self", NULL
44983 };
44984
44985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44987 if (SWIG_arg_fail(1)) SWIG_fail;
44988 {
44989 PyThreadState* __tstate = wxPyBeginAllowThreads();
44990 result = (wxRelationship)(arg1)->GetRelationship();
44991
44992 wxPyEndAllowThreads(__tstate);
44993 if (PyErr_Occurred()) SWIG_fail;
44994 }
44995 resultobj = SWIG_From_int((result));
44996 return resultobj;
44997 fail:
44998 return NULL;
44999 }
45000
45001
45002 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45003 PyObject *resultobj;
45004 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45005 wxRelationship arg2 ;
45006 PyObject * obj0 = 0 ;
45007 PyObject * obj1 = 0 ;
45008 char *kwnames[] = {
45009 (char *) "self",(char *) "r", NULL
45010 };
45011
45012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45014 if (SWIG_arg_fail(1)) SWIG_fail;
45015 {
45016 arg2 = (wxRelationship)(SWIG_As_int(obj1));
45017 if (SWIG_arg_fail(2)) SWIG_fail;
45018 }
45019 {
45020 PyThreadState* __tstate = wxPyBeginAllowThreads();
45021 (arg1)->SetRelationship((wxRelationship )arg2);
45022
45023 wxPyEndAllowThreads(__tstate);
45024 if (PyErr_Occurred()) SWIG_fail;
45025 }
45026 Py_INCREF(Py_None); resultobj = Py_None;
45027 return resultobj;
45028 fail:
45029 return NULL;
45030 }
45031
45032
45033 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45034 PyObject *resultobj;
45035 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45036 wxWindow *arg2 = (wxWindow *) 0 ;
45037 bool result;
45038 PyObject * obj0 = 0 ;
45039 PyObject * obj1 = 0 ;
45040 char *kwnames[] = {
45041 (char *) "self",(char *) "otherW", NULL
45042 };
45043
45044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45046 if (SWIG_arg_fail(1)) SWIG_fail;
45047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45048 if (SWIG_arg_fail(2)) SWIG_fail;
45049 {
45050 PyThreadState* __tstate = wxPyBeginAllowThreads();
45051 result = (bool)(arg1)->ResetIfWin(arg2);
45052
45053 wxPyEndAllowThreads(__tstate);
45054 if (PyErr_Occurred()) SWIG_fail;
45055 }
45056 {
45057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45058 }
45059 return resultobj;
45060 fail:
45061 return NULL;
45062 }
45063
45064
45065 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45066 PyObject *resultobj;
45067 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45068 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45069 wxWindow *arg3 = (wxWindow *) 0 ;
45070 bool result;
45071 PyObject * obj0 = 0 ;
45072 PyObject * obj1 = 0 ;
45073 PyObject * obj2 = 0 ;
45074 char *kwnames[] = {
45075 (char *) "self",(char *) "constraints",(char *) "win", NULL
45076 };
45077
45078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45080 if (SWIG_arg_fail(1)) SWIG_fail;
45081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45082 if (SWIG_arg_fail(2)) SWIG_fail;
45083 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45084 if (SWIG_arg_fail(3)) SWIG_fail;
45085 {
45086 PyThreadState* __tstate = wxPyBeginAllowThreads();
45087 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45088
45089 wxPyEndAllowThreads(__tstate);
45090 if (PyErr_Occurred()) SWIG_fail;
45091 }
45092 {
45093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45094 }
45095 return resultobj;
45096 fail:
45097 return NULL;
45098 }
45099
45100
45101 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45102 PyObject *resultobj;
45103 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45104 wxEdge arg2 ;
45105 wxWindow *arg3 = (wxWindow *) 0 ;
45106 wxWindow *arg4 = (wxWindow *) 0 ;
45107 int result;
45108 PyObject * obj0 = 0 ;
45109 PyObject * obj1 = 0 ;
45110 PyObject * obj2 = 0 ;
45111 PyObject * obj3 = 0 ;
45112 char *kwnames[] = {
45113 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45114 };
45115
45116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45118 if (SWIG_arg_fail(1)) SWIG_fail;
45119 {
45120 arg2 = (wxEdge)(SWIG_As_int(obj1));
45121 if (SWIG_arg_fail(2)) SWIG_fail;
45122 }
45123 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45124 if (SWIG_arg_fail(3)) SWIG_fail;
45125 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45126 if (SWIG_arg_fail(4)) SWIG_fail;
45127 {
45128 PyThreadState* __tstate = wxPyBeginAllowThreads();
45129 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45130
45131 wxPyEndAllowThreads(__tstate);
45132 if (PyErr_Occurred()) SWIG_fail;
45133 }
45134 {
45135 resultobj = SWIG_From_int((int)(result));
45136 }
45137 return resultobj;
45138 fail:
45139 return NULL;
45140 }
45141
45142
45143 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45144 PyObject *obj;
45145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45146 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45147 Py_INCREF(obj);
45148 return Py_BuildValue((char *)"");
45149 }
45150 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45151 PyObject *resultobj;
45152 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45153 wxIndividualLayoutConstraint *result;
45154 PyObject * obj0 = 0 ;
45155 char *kwnames[] = {
45156 (char *) "self", NULL
45157 };
45158
45159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45161 if (SWIG_arg_fail(1)) SWIG_fail;
45162 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45163
45164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45172 PyObject *resultobj;
45173 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45174 wxIndividualLayoutConstraint *result;
45175 PyObject * obj0 = 0 ;
45176 char *kwnames[] = {
45177 (char *) "self", NULL
45178 };
45179
45180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45182 if (SWIG_arg_fail(1)) SWIG_fail;
45183 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45184
45185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45186 return resultobj;
45187 fail:
45188 return NULL;
45189 }
45190
45191
45192 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45193 PyObject *resultobj;
45194 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45195 wxIndividualLayoutConstraint *result;
45196 PyObject * obj0 = 0 ;
45197 char *kwnames[] = {
45198 (char *) "self", NULL
45199 };
45200
45201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45203 if (SWIG_arg_fail(1)) SWIG_fail;
45204 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45205
45206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45207 return resultobj;
45208 fail:
45209 return NULL;
45210 }
45211
45212
45213 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45214 PyObject *resultobj;
45215 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45216 wxIndividualLayoutConstraint *result;
45217 PyObject * obj0 = 0 ;
45218 char *kwnames[] = {
45219 (char *) "self", NULL
45220 };
45221
45222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45224 if (SWIG_arg_fail(1)) SWIG_fail;
45225 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45226
45227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45228 return resultobj;
45229 fail:
45230 return NULL;
45231 }
45232
45233
45234 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45235 PyObject *resultobj;
45236 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45237 wxIndividualLayoutConstraint *result;
45238 PyObject * obj0 = 0 ;
45239 char *kwnames[] = {
45240 (char *) "self", NULL
45241 };
45242
45243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45245 if (SWIG_arg_fail(1)) SWIG_fail;
45246 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45247
45248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45249 return resultobj;
45250 fail:
45251 return NULL;
45252 }
45253
45254
45255 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45256 PyObject *resultobj;
45257 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45258 wxIndividualLayoutConstraint *result;
45259 PyObject * obj0 = 0 ;
45260 char *kwnames[] = {
45261 (char *) "self", NULL
45262 };
45263
45264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45266 if (SWIG_arg_fail(1)) SWIG_fail;
45267 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45268
45269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45270 return resultobj;
45271 fail:
45272 return NULL;
45273 }
45274
45275
45276 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45277 PyObject *resultobj;
45278 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45279 wxIndividualLayoutConstraint *result;
45280 PyObject * obj0 = 0 ;
45281 char *kwnames[] = {
45282 (char *) "self", NULL
45283 };
45284
45285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45287 if (SWIG_arg_fail(1)) SWIG_fail;
45288 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45289
45290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45291 return resultobj;
45292 fail:
45293 return NULL;
45294 }
45295
45296
45297 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45298 PyObject *resultobj;
45299 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45300 wxIndividualLayoutConstraint *result;
45301 PyObject * obj0 = 0 ;
45302 char *kwnames[] = {
45303 (char *) "self", NULL
45304 };
45305
45306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45308 if (SWIG_arg_fail(1)) SWIG_fail;
45309 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45310
45311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45312 return resultobj;
45313 fail:
45314 return NULL;
45315 }
45316
45317
45318 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45319 PyObject *resultobj;
45320 wxLayoutConstraints *result;
45321 char *kwnames[] = {
45322 NULL
45323 };
45324
45325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45326 {
45327 PyThreadState* __tstate = wxPyBeginAllowThreads();
45328 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45329
45330 wxPyEndAllowThreads(__tstate);
45331 if (PyErr_Occurred()) SWIG_fail;
45332 }
45333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45334 return resultobj;
45335 fail:
45336 return NULL;
45337 }
45338
45339
45340 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45341 PyObject *resultobj;
45342 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45343 wxWindow *arg2 = (wxWindow *) 0 ;
45344 int *arg3 = (int *) 0 ;
45345 bool result;
45346 int temp3 ;
45347 int res3 = 0 ;
45348 PyObject * obj0 = 0 ;
45349 PyObject * obj1 = 0 ;
45350 char *kwnames[] = {
45351 (char *) "self",(char *) "win", NULL
45352 };
45353
45354 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45357 if (SWIG_arg_fail(1)) SWIG_fail;
45358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45359 if (SWIG_arg_fail(2)) SWIG_fail;
45360 {
45361 PyThreadState* __tstate = wxPyBeginAllowThreads();
45362 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45363
45364 wxPyEndAllowThreads(__tstate);
45365 if (PyErr_Occurred()) SWIG_fail;
45366 }
45367 {
45368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45369 }
45370 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45371 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45372 return resultobj;
45373 fail:
45374 return NULL;
45375 }
45376
45377
45378 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45379 PyObject *resultobj;
45380 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45381 bool result;
45382 PyObject * obj0 = 0 ;
45383 char *kwnames[] = {
45384 (char *) "self", NULL
45385 };
45386
45387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45389 if (SWIG_arg_fail(1)) SWIG_fail;
45390 {
45391 PyThreadState* __tstate = wxPyBeginAllowThreads();
45392 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45393
45394 wxPyEndAllowThreads(__tstate);
45395 if (PyErr_Occurred()) SWIG_fail;
45396 }
45397 {
45398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45399 }
45400 return resultobj;
45401 fail:
45402 return NULL;
45403 }
45404
45405
45406 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45407 PyObject *obj;
45408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45409 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45410 Py_INCREF(obj);
45411 return Py_BuildValue((char *)"");
45412 }
45413 static PyMethodDef SwigMethods[] = {
45414 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45415 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45416 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45419 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45440 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45453 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45468 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45522 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45550 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45569 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45571 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45579 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45580 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45592 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45604 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45608 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45614 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45624 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45634 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45641 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45721 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45723 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45725 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45727 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45729 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45731 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45733 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45735 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45737 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45739 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45741 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45743 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45745 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45759 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45777 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45780 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45783 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45795 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45800 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45806 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45812 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45875 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45882 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45918 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45928 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45934 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45936 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45938 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45941 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45945 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45948 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45951 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45953 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45958 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45966 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45970 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45973 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45975 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45979 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45996 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45998 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46001 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46003 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46007 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46011 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46022 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46025 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46028 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46032 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46039 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46044 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46049 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46053 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46098 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46118 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46125 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46129 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46139 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46312 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46353 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46368 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46371 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46426 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46455 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46499 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46507 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46526 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46527 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46564 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46594 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46597 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46601 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46604 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46614 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46626 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46638 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46648 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46658 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46672 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46679 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46680 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46681 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46682 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46683 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46688 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46715 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46727 { NULL, NULL, 0, NULL }
46728 };
46729
46730
46731 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46732
46733 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46734 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46735 }
46736 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46737 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46738 }
46739 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46740 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46741 }
46742 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46743 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46744 }
46745 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46746 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46747 }
46748 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46749 return (void *)((wxSizer *) ((wxGridSizer *) x));
46750 }
46751 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46752 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46753 }
46754 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46755 return (void *)((wxSizer *) ((wxPySizer *) x));
46756 }
46757 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46758 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46759 }
46760 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46761 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46762 }
46763 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46764 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46765 }
46766 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46767 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46768 }
46769 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46770 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46771 }
46772 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46773 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46774 }
46775 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46776 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46777 }
46778 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46779 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46780 }
46781 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46782 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46783 }
46784 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46785 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46786 }
46787 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46788 return (void *)((wxEvent *) ((wxPyEvent *) x));
46789 }
46790 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46791 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46792 }
46793 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46794 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46795 }
46796 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46797 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46798 }
46799 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46800 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46801 }
46802 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46803 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46804 }
46805 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46806 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46807 }
46808 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46809 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46810 }
46811 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46812 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46813 }
46814 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46815 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46816 }
46817 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46818 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46819 }
46820 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46821 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46822 }
46823 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46824 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46825 }
46826 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46827 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46828 }
46829 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46830 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46831 }
46832 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46833 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46834 }
46835 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46836 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46837 }
46838 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46839 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46840 }
46841 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46842 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46843 }
46844 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46845 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46846 }
46847 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46848 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46849 }
46850 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46851 return (void *)((wxEvent *) ((wxShowEvent *) x));
46852 }
46853 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46854 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46855 }
46856 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46857 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46858 }
46859 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46860 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46861 }
46862 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46863 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46864 }
46865 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46866 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46867 }
46868 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46869 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46870 }
46871 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46872 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46873 }
46874 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46875 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46876 }
46877 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46878 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46879 }
46880 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46881 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46882 }
46883 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46884 return (void *)((wxControl *) ((wxControlWithItems *) x));
46885 }
46886 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46887 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46888 }
46889 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46890 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46891 }
46892 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46893 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46894 }
46895 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46896 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46897 }
46898 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46899 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46900 }
46901 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46902 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46903 }
46904 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46905 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46906 }
46907 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46908 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46909 }
46910 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46911 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46912 }
46913 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46914 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46915 }
46916 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46917 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46918 }
46919 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46920 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46921 }
46922 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46923 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46924 }
46925 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46926 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46927 }
46928 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46929 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46930 }
46931 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46932 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46933 }
46934 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46935 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46936 }
46937 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46938 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46939 }
46940 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46941 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46942 }
46943 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46944 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46945 }
46946 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46947 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46948 }
46949 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46950 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46951 }
46952 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46953 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46954 }
46955 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46956 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46957 }
46958 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46959 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46960 }
46961 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46962 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46963 }
46964 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46965 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46966 }
46967 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46968 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46969 }
46970 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46971 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46972 }
46973 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46974 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46975 }
46976 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46977 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46978 }
46979 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46980 return (void *)((wxObject *) ((wxSizerItem *) x));
46981 }
46982 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46983 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46984 }
46985 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46986 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46987 }
46988 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46989 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46990 }
46991 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46992 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46993 }
46994 static void *_p_wxSizerTo_p_wxObject(void *x) {
46995 return (void *)((wxObject *) ((wxSizer *) x));
46996 }
46997 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46998 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46999 }
47000 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47001 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47002 }
47003 static void *_p_wxEventTo_p_wxObject(void *x) {
47004 return (void *)((wxObject *) ((wxEvent *) x));
47005 }
47006 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47007 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47008 }
47009 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47010 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47011 }
47012 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47013 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47014 }
47015 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47016 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47017 }
47018 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47019 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47020 }
47021 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47022 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47023 }
47024 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47025 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47026 }
47027 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47028 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47029 }
47030 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47031 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47032 }
47033 static void *_p_wxControlTo_p_wxObject(void *x) {
47034 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47035 }
47036 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47037 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47038 }
47039 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47040 return (void *)((wxObject *) ((wxFSFile *) x));
47041 }
47042 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47043 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47044 }
47045 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47046 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47047 }
47048 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47049 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47050 }
47051 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47052 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47053 }
47054 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47055 return (void *)((wxObject *) ((wxMenuItem *) x));
47056 }
47057 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47058 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47059 }
47060 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47061 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47062 }
47063 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47064 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47065 }
47066 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47067 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47068 }
47069 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47070 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47071 }
47072 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47073 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47074 }
47075 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47076 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47077 }
47078 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47079 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47080 }
47081 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47082 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47083 }
47084 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47085 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47086 }
47087 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47088 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47089 }
47090 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47091 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47092 }
47093 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47094 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47095 }
47096 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47097 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47098 }
47099 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47100 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47101 }
47102 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47103 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47104 }
47105 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47106 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47107 }
47108 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47109 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47110 }
47111 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47112 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47113 }
47114 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47115 return (void *)((wxObject *) ((wxImageHandler *) x));
47116 }
47117 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47118 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47119 }
47120 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47121 return (void *)((wxObject *) ((wxEvtHandler *) x));
47122 }
47123 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47124 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47125 }
47126 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47127 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47128 }
47129 static void *_p_wxImageTo_p_wxObject(void *x) {
47130 return (void *)((wxObject *) ((wxImage *) x));
47131 }
47132 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47133 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47134 }
47135 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47136 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47137 }
47138 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47139 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47140 }
47141 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47142 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47143 }
47144 static void *_p_wxWindowTo_p_wxObject(void *x) {
47145 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47146 }
47147 static void *_p_wxMenuTo_p_wxObject(void *x) {
47148 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47149 }
47150 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47151 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47152 }
47153 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47154 return (void *)((wxObject *) ((wxFileSystem *) x));
47155 }
47156 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47157 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47158 }
47159 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47160 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47161 }
47162 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47163 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47164 }
47165 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47166 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47167 }
47168 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47169 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47170 }
47171 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47172 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47173 }
47174 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47175 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47176 }
47177 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47178 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47179 }
47180 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47181 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47182 }
47183 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47184 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47185 }
47186 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47187 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47188 }
47189 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47190 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47191 }
47192 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47193 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47194 }
47195 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47196 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47197 }
47198 static void *_p_wxControlTo_p_wxWindow(void *x) {
47199 return (void *)((wxWindow *) ((wxControl *) x));
47200 }
47201 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47202 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47203 }
47204 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47205 return (void *)((wxWindow *) ((wxMenuBar *) x));
47206 }
47207 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47208 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47209 }
47210 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47211 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47212 }
47213 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47214 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47215 }
47216 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47217 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47218 }
47219 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47220 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47221 }
47222 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47223 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47224 }
47225 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47226 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47227 }
47228 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47229 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47230 }
47231 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47232 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47233 }
47234 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47235 return (void *)((wxValidator *) ((wxPyValidator *) x));
47236 }
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 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}};
47250 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}};
47251 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47252 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}};
47253 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}};
47254 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}};
47255 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}};
47256 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}};
47257 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}};
47258 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}};
47259 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}};
47260 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}};
47261 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}};
47262 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}};
47263 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}};
47264 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}};
47265 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}};
47266 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}};
47267 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}};
47268 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}};
47269 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}};
47270 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}};
47271 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}};
47272 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}};
47273 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}};
47274 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}};
47275 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}};
47276 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}};
47277 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}};
47278 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}};
47279 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}};
47280 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}};
47281 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}};
47282 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}};
47283 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}};
47284 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}};
47285 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}};
47286 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}};
47287 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}};
47288 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}};
47289 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}};
47290 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}};
47291 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}};
47292 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}};
47293 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}};
47294 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}};
47295 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}};
47296 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}};
47297 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}};
47298 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}};
47299 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}};
47300 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}};
47301 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}};
47302 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}};
47303 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}};
47304 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}};
47305 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}};
47306 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}};
47307 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}};
47308 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}};
47309 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}};
47310 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}};
47311 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}};
47312 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}};
47313 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}};
47314 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}};
47315 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}};
47316 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}};
47317 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}};
47318 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}};
47319 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}};
47320 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}};
47321 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}};
47322 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}};
47323 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}};
47324 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}};
47325 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}};
47326 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}};
47327 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}};
47328 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}};
47329 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}};
47330 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}};
47331 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}};
47332 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}};
47333 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}};
47334 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}};
47335 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}};
47336 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}};
47337 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}};
47338 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}};
47339 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}};
47340 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}};
47341 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}};
47342 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}};
47343 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}};
47344 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}};
47345 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}};
47346 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}};
47347 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}};
47348 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}};
47349 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}};
47350 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}};
47351 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}};
47352 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}};
47353 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}};
47354 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}};
47355 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}};
47356 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}};
47357 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}};
47358 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}};
47359 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}};
47360 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}};
47361 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}};
47362 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}};
47363 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}};
47364 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}};
47365
47366 static swig_type_info *swig_types_initial[] = {
47367 _swigt__p_wxLayoutConstraints,
47368 _swigt__p_wxRealPoint,
47369 _swigt__p_wxSizerItem,
47370 _swigt__p_wxGBSizerItem,
47371 _swigt__p_wxScrollEvent,
47372 _swigt__p_wxEventLoop,
47373 _swigt__p_wxIndividualLayoutConstraint,
47374 _swigt__p_wxSizer,
47375 _swigt__p_wxBoxSizer,
47376 _swigt__p_wxStaticBoxSizer,
47377 _swigt__p_wxGridBagSizer,
47378 _swigt__p_wxAcceleratorEntry,
47379 _swigt__p_wxUpdateUIEvent,
47380 _swigt__p_wxEvent,
47381 _swigt__p_buffer,
47382 _swigt__p_wxMenu,
47383 _swigt__p_wxGridSizer,
47384 _swigt__p_wxFlexGridSizer,
47385 _swigt__p_wxInitDialogEvent,
47386 _swigt__p_wxItemContainer,
47387 _swigt__p_wxNcPaintEvent,
47388 _swigt__p_wxPaintEvent,
47389 _swigt__p_wxSysColourChangedEvent,
47390 _swigt__p_wxMouseCaptureChangedEvent,
47391 _swigt__p_wxDisplayChangedEvent,
47392 _swigt__p_wxPaletteChangedEvent,
47393 _swigt__p_wxControl,
47394 _swigt__p_wxFont,
47395 _swigt__p_wxMenuBarBase,
47396 _swigt__p_wxSetCursorEvent,
47397 _swigt__p_wxFSFile,
47398 _swigt__p_wxCaret,
47399 _swigt__ptrdiff_t,
47400 _swigt__std__ptrdiff_t,
47401 _swigt__p_wxRegion,
47402 _swigt__p_wxPoint2D,
47403 _swigt__p_int,
47404 _swigt__p_wxSize,
47405 _swigt__p_wxDC,
47406 _swigt__p_wxPySizer,
47407 _swigt__p_wxVisualAttributes,
47408 _swigt__p_wxNotifyEvent,
47409 _swigt__p_wxPyEvent,
47410 _swigt__p_wxPropagationDisabler,
47411 _swigt__p_form_ops_t,
47412 _swigt__p_wxAppTraits,
47413 _swigt__p_wxArrayString,
47414 _swigt__p_wxShowEvent,
47415 _swigt__p_wxToolTip,
47416 _swigt__p_wxMoveEvent,
47417 _swigt__p_wxSizeEvent,
47418 _swigt__p_wxActivateEvent,
47419 _swigt__p_wxIconizeEvent,
47420 _swigt__p_wxMaximizeEvent,
47421 _swigt__p_wxQueryNewPaletteEvent,
47422 _swigt__p_wxWindowCreateEvent,
47423 _swigt__p_wxIdleEvent,
47424 _swigt__p_wxDateEvent,
47425 _swigt__p_wxMenuItem,
47426 _swigt__p_wxStaticBox,
47427 _swigt__p_long,
47428 _swigt__p_wxDuplexMode,
47429 _swigt__p_wxTIFFHandler,
47430 _swigt__p_wxXPMHandler,
47431 _swigt__p_wxPNMHandler,
47432 _swigt__p_wxJPEGHandler,
47433 _swigt__p_wxPCXHandler,
47434 _swigt__p_wxGIFHandler,
47435 _swigt__p_wxPNGHandler,
47436 _swigt__p_wxANIHandler,
47437 _swigt__p_wxMemoryFSHandler,
47438 _swigt__p_wxZipFSHandler,
47439 _swigt__p_wxInternetFSHandler,
47440 _swigt__p_wxPyFileSystemHandler,
47441 _swigt__p_wxEvtHandler,
47442 _swigt__p_wxCURHandler,
47443 _swigt__p_wxICOHandler,
47444 _swigt__p_wxBMPHandler,
47445 _swigt__p_wxImageHandler,
47446 _swigt__p_wxFileSystemHandler,
47447 _swigt__p_wxRect,
47448 _swigt__p_wxButton,
47449 _swigt__p_wxGBSpan,
47450 _swigt__p_wxPropagateOnce,
47451 _swigt__p_wxAcceleratorTable,
47452 _swigt__p_wxStdDialogButtonSizer,
47453 _swigt__p_char,
47454 _swigt__p_wxGBPosition,
47455 _swigt__p_wxImage,
47456 _swigt__p_wxFrame,
47457 _swigt__p_wxScrollWinEvent,
47458 _swigt__p_wxPaperSize,
47459 _swigt__p_wxImageHistogram,
47460 _swigt__p_wxPoint,
47461 _swigt__p_wxCursor,
47462 _swigt__p_wxObject,
47463 _swigt__p_wxInputStream,
47464 _swigt__p_wxOutputStream,
47465 _swigt__p_wxPyInputStream,
47466 _swigt__p_wxDateTime,
47467 _swigt__p_wxKeyEvent,
47468 _swigt__p_wxNavigationKeyEvent,
47469 _swigt__p_wxWindowDestroyEvent,
47470 _swigt__p_unsigned_long,
47471 _swigt__p_wxWindow,
47472 _swigt__p_wxMenuBar,
47473 _swigt__p_wxFileSystem,
47474 _swigt__p_wxBitmap,
47475 _swigt__unsigned_int,
47476 _swigt__p_unsigned_int,
47477 _swigt__p_wxMenuEvent,
47478 _swigt__p_wxContextMenuEvent,
47479 _swigt__p_unsigned_char,
47480 _swigt__p_wxEraseEvent,
47481 _swigt__p_wxMouseEvent,
47482 _swigt__p_wxCloseEvent,
47483 _swigt__p_wxPyApp,
47484 _swigt__p_wxCommandEvent,
47485 _swigt__p_wxPyCommandEvent,
47486 _swigt__p_wxPyDropTarget,
47487 _swigt__p_wxQuantize,
47488 _swigt__p_wxFocusEvent,
47489 _swigt__p_wxChildFocusEvent,
47490 _swigt__p_wxDropFilesEvent,
47491 _swigt__p_wxControlWithItems,
47492 _swigt__p_wxColour,
47493 _swigt__p_wxValidator,
47494 _swigt__p_wxPyValidator,
47495 0
47496 };
47497
47498
47499 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47500
47501 static swig_const_info swig_const_table[] = {
47502 {0, 0, 0, 0.0, 0, 0}};
47503
47504 #ifdef __cplusplus
47505 }
47506 #endif
47507
47508
47509 #ifdef __cplusplus
47510 extern "C" {
47511 #endif
47512
47513 /* Python-specific SWIG API */
47514 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47515 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47516 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47517
47518 /* -----------------------------------------------------------------------------
47519 * global variable support code.
47520 * ----------------------------------------------------------------------------- */
47521
47522 typedef struct swig_globalvar {
47523 char *name; /* Name of global variable */
47524 PyObject *(*get_attr)(); /* Return the current value */
47525 int (*set_attr)(PyObject *); /* Set the value */
47526 struct swig_globalvar *next;
47527 } swig_globalvar;
47528
47529 typedef struct swig_varlinkobject {
47530 PyObject_HEAD
47531 swig_globalvar *vars;
47532 } swig_varlinkobject;
47533
47534 static PyObject *
47535 swig_varlink_repr(swig_varlinkobject *v) {
47536 v = v;
47537 return PyString_FromString("<Swig global variables>");
47538 }
47539
47540 static int
47541 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47542 swig_globalvar *var;
47543 flags = flags;
47544 fprintf(fp,"Swig global variables { ");
47545 for (var = v->vars; var; var=var->next) {
47546 fprintf(fp,"%s", var->name);
47547 if (var->next) fprintf(fp,", ");
47548 }
47549 fprintf(fp," }\n");
47550 return 0;
47551 }
47552
47553 static PyObject *
47554 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47555 swig_globalvar *var = v->vars;
47556 while (var) {
47557 if (strcmp(var->name,n) == 0) {
47558 return (*var->get_attr)();
47559 }
47560 var = var->next;
47561 }
47562 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47563 return NULL;
47564 }
47565
47566 static int
47567 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47568 swig_globalvar *var = v->vars;
47569 while (var) {
47570 if (strcmp(var->name,n) == 0) {
47571 return (*var->set_attr)(p);
47572 }
47573 var = var->next;
47574 }
47575 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47576 return 1;
47577 }
47578
47579 static PyTypeObject varlinktype = {
47580 PyObject_HEAD_INIT(0)
47581 0, /* Number of items in variable part (ob_size) */
47582 (char *)"swigvarlink", /* Type name (tp_name) */
47583 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47584 0, /* Itemsize (tp_itemsize) */
47585 0, /* Deallocator (tp_dealloc) */
47586 (printfunc) swig_varlink_print, /* Print (tp_print) */
47587 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47588 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47589 0, /* tp_compare */
47590 (reprfunc) swig_varlink_repr, /* tp_repr */
47591 0, /* tp_as_number */
47592 0, /* tp_as_sequence */
47593 0, /* tp_as_mapping */
47594 0, /* tp_hash */
47595 0, /* tp_call */
47596 0, /* tp_str */
47597 0, /* tp_getattro */
47598 0, /* tp_setattro */
47599 0, /* tp_as_buffer */
47600 0, /* tp_flags */
47601 0, /* tp_doc */
47602 #if PY_VERSION_HEX >= 0x02000000
47603 0, /* tp_traverse */
47604 0, /* tp_clear */
47605 #endif
47606 #if PY_VERSION_HEX >= 0x02010000
47607 0, /* tp_richcompare */
47608 0, /* tp_weaklistoffset */
47609 #endif
47610 #if PY_VERSION_HEX >= 0x02020000
47611 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47612 #endif
47613 #if PY_VERSION_HEX >= 0x02030000
47614 0, /* tp_del */
47615 #endif
47616 #ifdef COUNT_ALLOCS
47617 0,0,0,0 /* tp_alloc -> tp_next */
47618 #endif
47619 };
47620
47621 /* Create a variable linking object for use later */
47622 static PyObject *
47623 SWIG_Python_newvarlink(void) {
47624 swig_varlinkobject *result = 0;
47625 result = PyMem_NEW(swig_varlinkobject,1);
47626 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47627 result->ob_type = &varlinktype;
47628 result->vars = 0;
47629 result->ob_refcnt = 0;
47630 Py_XINCREF((PyObject *) result);
47631 return ((PyObject*) result);
47632 }
47633
47634 static void
47635 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47636 swig_varlinkobject *v;
47637 swig_globalvar *gv;
47638 v= (swig_varlinkobject *) p;
47639 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47640 gv->name = (char *) malloc(strlen(name)+1);
47641 strcpy(gv->name,name);
47642 gv->get_attr = get_attr;
47643 gv->set_attr = set_attr;
47644 gv->next = v->vars;
47645 v->vars = gv;
47646 }
47647
47648 /* -----------------------------------------------------------------------------
47649 * constants/methods manipulation
47650 * ----------------------------------------------------------------------------- */
47651
47652 /* Install Constants */
47653 static void
47654 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47655 PyObject *obj = 0;
47656 size_t i;
47657 for (i = 0; constants[i].type; i++) {
47658 switch(constants[i].type) {
47659 case SWIG_PY_INT:
47660 obj = PyInt_FromLong(constants[i].lvalue);
47661 break;
47662 case SWIG_PY_FLOAT:
47663 obj = PyFloat_FromDouble(constants[i].dvalue);
47664 break;
47665 case SWIG_PY_STRING:
47666 if (constants[i].pvalue) {
47667 obj = PyString_FromString((char *) constants[i].pvalue);
47668 } else {
47669 Py_INCREF(Py_None);
47670 obj = Py_None;
47671 }
47672 break;
47673 case SWIG_PY_POINTER:
47674 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47675 break;
47676 case SWIG_PY_BINARY:
47677 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47678 break;
47679 default:
47680 obj = 0;
47681 break;
47682 }
47683 if (obj) {
47684 PyDict_SetItemString(d,constants[i].name,obj);
47685 Py_DECREF(obj);
47686 }
47687 }
47688 }
47689
47690 /* -----------------------------------------------------------------------------*/
47691 /* Fix SwigMethods to carry the callback ptrs when needed */
47692 /* -----------------------------------------------------------------------------*/
47693
47694 static void
47695 SWIG_Python_FixMethods(PyMethodDef *methods,
47696 swig_const_info *const_table,
47697 swig_type_info **types,
47698 swig_type_info **types_initial) {
47699 size_t i;
47700 for (i = 0; methods[i].ml_name; ++i) {
47701 char *c = methods[i].ml_doc;
47702 if (c && (c = strstr(c, "swig_ptr: "))) {
47703 int j;
47704 swig_const_info *ci = 0;
47705 char *name = c + 10;
47706 for (j = 0; const_table[j].type; j++) {
47707 if (strncmp(const_table[j].name, name,
47708 strlen(const_table[j].name)) == 0) {
47709 ci = &(const_table[j]);
47710 break;
47711 }
47712 }
47713 if (ci) {
47714 size_t shift = (ci->ptype) - types;
47715 swig_type_info *ty = types_initial[shift];
47716 size_t ldoc = (c - methods[i].ml_doc);
47717 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47718 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47719 char *buff = ndoc;
47720 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47721 strncpy(buff, methods[i].ml_doc, ldoc);
47722 buff += ldoc;
47723 strncpy(buff, "swig_ptr: ", 10);
47724 buff += 10;
47725 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47726 methods[i].ml_doc = ndoc;
47727 }
47728 }
47729 }
47730 }
47731
47732 /* -----------------------------------------------------------------------------*
47733 * Initialize type list
47734 * -----------------------------------------------------------------------------*/
47735
47736 #if PY_MAJOR_VERSION < 2
47737 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47738 is copied out of Python/modsupport.c in python version 2.3.4 */
47739 static int
47740 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47741 {
47742 PyObject *dict;
47743 if (!PyModule_Check(m)) {
47744 PyErr_SetString(PyExc_TypeError,
47745 "PyModule_AddObject() needs module as first arg");
47746 return -1;
47747 }
47748 if (!o) {
47749 PyErr_SetString(PyExc_TypeError,
47750 "PyModule_AddObject() needs non-NULL value");
47751 return -1;
47752 }
47753
47754 dict = PyModule_GetDict(m);
47755 if (dict == NULL) {
47756 /* Internal error -- modules must have a dict! */
47757 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47758 PyModule_GetName(m));
47759 return -1;
47760 }
47761 if (PyDict_SetItemString(dict, name, o))
47762 return -1;
47763 Py_DECREF(o);
47764 return 0;
47765 }
47766 #endif
47767
47768 static swig_type_info **
47769 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47770 static PyMethodDef swig_empty_runtime_method_table[] = {
47771 {
47772 NULL, NULL, 0, NULL
47773 }
47774 };/* Sentinel */
47775
47776 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47777 swig_empty_runtime_method_table);
47778 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47779 if (pointer && module) {
47780 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47781 }
47782 return type_list_handle;
47783 }
47784
47785 static swig_type_info **
47786 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47787 swig_type_info **type_pointer;
47788
47789 /* first check if module already created */
47790 type_pointer = SWIG_Python_GetTypeListHandle();
47791 if (type_pointer) {
47792 return type_pointer;
47793 } else {
47794 /* create a new module and variable */
47795 return SWIG_Python_SetTypeListHandle(type_list_handle);
47796 }
47797 }
47798
47799 #ifdef __cplusplus
47800 }
47801 #endif
47802
47803 /* -----------------------------------------------------------------------------*
47804 * Partial Init method
47805 * -----------------------------------------------------------------------------*/
47806
47807 #ifdef SWIG_LINK_RUNTIME
47808 #ifdef __cplusplus
47809 extern "C"
47810 #endif
47811 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47812 #endif
47813
47814 #ifdef __cplusplus
47815 extern "C"
47816 #endif
47817 SWIGEXPORT(void) SWIG_init(void) {
47818 static PyObject *SWIG_globals = 0;
47819 static int typeinit = 0;
47820 PyObject *m, *d;
47821 int i;
47822 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47823
47824 /* Fix SwigMethods to carry the callback ptrs when needed */
47825 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47826
47827 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47828 d = PyModule_GetDict(m);
47829
47830 if (!typeinit) {
47831 #ifdef SWIG_LINK_RUNTIME
47832 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47833 #else
47834 # ifndef SWIG_STATIC_RUNTIME
47835 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47836 # endif
47837 #endif
47838 for (i = 0; swig_types_initial[i]; i++) {
47839 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47840 }
47841 typeinit = 1;
47842 }
47843 SWIG_InstallConstants(d,swig_const_table);
47844
47845
47846 #ifndef wxPyUSE_EXPORT
47847 // Make our API structure a CObject so other modules can import it
47848 // from this module.
47849 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47850 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47851 Py_XDECREF(cobj);
47852 #endif
47853
47854 {
47855 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int((int)(wxPAPER_A6)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int((int)(wxPAPER_JENV_KAKU2)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int((int)(wxPAPER_JENV_KAKU3)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int((int)(wxPAPER_JENV_CHOU3)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int((int)(wxPAPER_JENV_CHOU4)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int((int)(wxPAPER_LETTER_ROTATED)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int((int)(wxPAPER_A3_ROTATED)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int((int)(wxPAPER_A4_ROTATED)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int((int)(wxPAPER_A5_ROTATED)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B4_JIS_ROTATED)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B5_JIS_ROTATED)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int((int)(wxPAPER_A6_ROTATED)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU2_ROTATED)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU3_ROTATED)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU3_ROTATED)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU4_ROTATED)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int((int)(wxPAPER_B6_JIS)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B6_JIS_ROTATED)));
49485 }
49486 {
49487 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int((int)(wxPAPER_12X11)));
49488 }
49489 {
49490 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int((int)(wxPAPER_JENV_YOU4)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_YOU4_ROTATED)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int((int)(wxPAPER_P16K)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int((int)(wxPAPER_P32K)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int((int)(wxPAPER_P32KBIG)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int((int)(wxPAPER_PENV_1)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int((int)(wxPAPER_PENV_2)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int((int)(wxPAPER_PENV_3)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int((int)(wxPAPER_PENV_4)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int((int)(wxPAPER_PENV_5)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int((int)(wxPAPER_PENV_6)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int((int)(wxPAPER_PENV_7)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int((int)(wxPAPER_PENV_8)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int((int)(wxPAPER_PENV_9)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int((int)(wxPAPER_PENV_10)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int((int)(wxPAPER_P16K_ROTATED)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int((int)(wxPAPER_P32K_ROTATED)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int((int)(wxPAPER_P32KBIG_ROTATED)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_1_ROTATED)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_2_ROTATED)));
49548 }
49549 {
49550 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_3_ROTATED)));
49551 }
49552 {
49553 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_4_ROTATED)));
49554 }
49555 {
49556 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_5_ROTATED)));
49557 }
49558 {
49559 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_6_ROTATED)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_7_ROTATED)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_8_ROTATED)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_9_ROTATED)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_10_ROTATED)));
49572 }
49573 {
49574 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49575 }
49576 {
49577 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49578 }
49579 {
49580 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49581 }
49582 {
49583 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49584 }
49585 {
49586 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49587 }
49588 {
49589 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49602 }
49603 {
49604 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49617 }
49618 {
49619 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49620 }
49621 {
49622 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49635 }
49636 {
49637 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49641 }
49642 {
49643 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49644 }
49645 {
49646 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49647 }
49648 {
49649 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49650 }
49651 {
49652 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49653 }
49654 {
49655 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49656 }
49657 {
49658 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49659 }
49660 {
49661 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49662 }
49663 {
49664 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49665 }
49666 {
49667 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49668 }
49669 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49670 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49671 {
49672 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49673 }
49674 {
49675 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49676 }
49677 {
49678 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49679 }
49680 {
49681 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49682 }
49683 {
49684 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49685 }
49686 {
49687 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49688 }
49689 {
49690 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49691 }
49692 {
49693 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49700 }
49701 {
49702 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49703 }
49704 {
49705 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49706 }
49707 {
49708 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49709 }
49710 {
49711 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49712 }
49713 {
49714 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49715 }
49716 {
49717 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49718 }
49719 {
49720 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49721 }
49722 {
49723 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49724 }
49725 {
49726 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49727 }
49728 {
49729 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49733 }
49734 {
49735 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49736 }
49737 {
49738 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49739 }
49740 {
49741 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49742 }
49743 {
49744 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49745 }
49746 {
49747 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49748 }
49749 {
49750 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49751 }
49752 {
49753 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49754 }
49755 {
49756 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49757 }
49758 {
49759 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49760 }
49761 {
49762 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49763 }
49764 {
49765 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49766 }
49767 {
49768 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49769 }
49770 {
49771 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49772 }
49773 {
49774 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49775 }
49776 {
49777 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49778 }
49779 {
49780 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49781 }
49782 {
49783 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49784 }
49785 {
49786 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49787 }
49788 {
49789 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49790 }
49791 {
49792 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49793 }
49794 {
49795 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49796 }
49797 {
49798 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49799 }
49800 {
49801 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49802 }
49803 {
49804 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49808 }
49809 {
49810 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49811 }
49812 {
49813 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49814 }
49815 {
49816 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49817 }
49818 {
49819 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49820 }
49821 {
49822 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49823 }
49824 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49825 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49826 {
49827 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49828 }
49829 {
49830 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49831 }
49832 {
49833 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49834 }
49835
49836 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49837
49838
49839 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49840
49841 {
49842 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49843 }
49844 {
49845 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49846 }
49847 {
49848 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49849 }
49850 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49851 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49852 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49853 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49854 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49855 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49856 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49857 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49858 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49859 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49860 {
49861 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49862 }
49863 {
49864 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49865 }
49866 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49867 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49868 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49869 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49870 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49871 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49872 {
49873 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49874 }
49875 {
49876 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49877 }
49878 {
49879 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49880 }
49881 {
49882 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49883 }
49884 {
49885 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49886 }
49887 {
49888 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49889 }
49890 {
49891 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49892 }
49893 {
49894 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49901 }
49902 {
49903 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49904 }
49905 {
49906 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49907 }
49908 {
49909 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49910 }
49911 {
49912 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49913 }
49914 {
49915 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49916 }
49917 {
49918 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49919 }
49920 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49921 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49922 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49923 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49924 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49925 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49926 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49927 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49928 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49929 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49930 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49931 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49932 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49933 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49934 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49935 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49936 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49937 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49938 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49939 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49940 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49941 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49942 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49943 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49944 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49945 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49946 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49947 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49948 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49949 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49950 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49951 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49952 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49953 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49954 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49955 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49956 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49957 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49958 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49959 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49960 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49961 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49962 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49963 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49964 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49965 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49966 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49967 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49968 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49969 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49970 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49971 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49972 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49973 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49974 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49975 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49976 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49977 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49978 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49979 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49980 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49981 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49982 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
49983 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49984 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49985 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49986 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49987 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49988 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49989 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49990 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49991 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49992 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49993 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49994 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49995 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49996 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49997 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49998 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49999 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
50000 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
50001 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
50002 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
50003 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
50004 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
50005 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
50006 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
50007 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
50008 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
50009 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
50010 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
50011 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
50012 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
50013 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
50014 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
50015 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
50016 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
50017 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
50018 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
50019 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
50020 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
50021 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
50022 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
50023 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
50024 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
50025 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
50026 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
50027 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
50028 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
50029 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
50030 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
50031 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
50032 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
50033 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
50034 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
50035 {
50036 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
50037 }
50038 {
50039 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
50040 }
50041 {
50042 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
50043 }
50044 {
50045 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
50046 }
50047 {
50048 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
50049 }
50050 {
50051 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
50052 }
50053 {
50054 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
50055 }
50056 {
50057 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
50058 }
50059 {
50060 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
50061 }
50062 {
50063 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
50064 }
50065 {
50066 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
50067 }
50068 {
50069 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
50070 }
50071 {
50072 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
50073 }
50074 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
50075 {
50076 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
50077 }
50078 {
50079 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
50080 }
50081 {
50082 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
50083 }
50084 {
50085 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
50086 }
50087 {
50088 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
50089 }
50090 {
50091 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
50092 }
50093 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
50094 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
50095 {
50096 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
50097 }
50098 {
50099 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
50100 }
50101 {
50102 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
50103 }
50104 {
50105 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
50106 }
50107 {
50108 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
50109 }
50110 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
50111 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
50112 {
50113 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
50114 }
50115 {
50116 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
50117 }
50118 {
50119 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
50120 }
50121 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
50122 {
50123 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
50124 }
50125 {
50126 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
50127 }
50128 {
50129 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
50130 }
50131 {
50132 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
50133 }
50134 {
50135 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
50136 }
50137 {
50138 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
50139 }
50140 {
50141 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
50142 }
50143 {
50144 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
50145 }
50146 {
50147 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
50148 }
50149 {
50150 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
50151 }
50152 {
50153 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
50154 }
50155 {
50156 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
50157 }
50158 {
50159 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
50160 }
50161 {
50162 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
50163 }
50164 {
50165 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
50166 }
50167 {
50168 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
50169 }
50170 {
50171 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
50172 }
50173 {
50174 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
50175 }
50176 {
50177 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
50178 }
50179
50180 // Initialize threading, some globals and such
50181 __wxPyPreStart(d);
50182
50183
50184 // Although these are defined in __version__ they need to be here too so
50185 // that an assert can be done to ensure that the wxPython and the wxWindows
50186 // versions match.
50187 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
50188 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
50189 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
50190
50191 }
50192
wxWidgets (Impactor)