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


183b31354256393ef38ac0c09fa389db2849f349
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652 wxPyCBInputStream_copy,
1653
1654 wxPyInstance_Check,
1655 wxPySwigInstance_Check,
1656
1657 wxPyCheckForApp
1658
1659 };
1660
1661 #endif
1662
1663
1664 #if !WXWIN_COMPATIBILITY_2_4
1665 #define wxHIDE_READONLY 0
1666 #endif
1667
1668
1669 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1670 #define SWIG_From_int PyInt_FromLong
1671 /*@@*/
1672
1673
1674 #if ! wxUSE_HOTKEY
1675 enum wxHotkeyModifier
1676 {
1677 wxMOD_NONE = 0,
1678 wxMOD_ALT = 1,
1679 wxMOD_CONTROL = 2,
1680 wxMOD_SHIFT = 4,
1681 wxMOD_WIN = 8
1682 };
1683 #define wxEVT_HOTKEY 9999
1684 #endif
1685
1686 static const wxString wxPyEmptyString(wxEmptyString);
1687 static wxString wxObject_GetClassName(wxObject *self){
1688 return self->GetClassInfo()->GetClassName();
1689 }
1690 static void wxObject_Destroy(wxObject *self){
1691 delete self;
1692 }
1693
1694 #ifndef __WXMAC__
1695 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1696 #endif
1697
1698
1699 #include <limits.h>
1700
1701
1702 SWIGINTERN int
1703 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1704 const char *errmsg)
1705 {
1706 if (value < min_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is less than '%s' minimum %ld",
1710 value, errmsg, min_value);
1711 }
1712 return 0;
1713 } else if (value > max_value) {
1714 if (errmsg) {
1715 PyErr_Format(PyExc_OverflowError,
1716 "value %ld is greater than '%s' maximum %ld",
1717 value, errmsg, max_value);
1718 }
1719 return 0;
1720 }
1721 return 1;
1722 }
1723
1724
1725 SWIGINTERN int
1726 SWIG_AsVal_long(PyObject* obj, long* val)
1727 {
1728 if (PyNumber_Check(obj)) {
1729 if (val) *val = PyInt_AsLong(obj);
1730 return 1;
1731 }
1732 else {
1733 SWIG_type_error("number", obj);
1734 }
1735 return 0;
1736 }
1737
1738
1739 #if INT_MAX != LONG_MAX
1740 SWIGINTERN int
1741 SWIG_AsVal_int(PyObject *obj, int *val)
1742 {
1743 const char* errmsg = val ? "int" : (char*)0;
1744 long v;
1745 if (SWIG_AsVal_long(obj, &v)) {
1746 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1747 if (val) *val = (int)(v);
1748 return 1;
1749 } else {
1750 return 0;
1751 }
1752 } else {
1753 PyErr_Clear();
1754 }
1755 if (val) {
1756 SWIG_type_error(errmsg, obj);
1757 }
1758 return 0;
1759 }
1760 #else
1761 SWIGINTERNSHORT int
1762 SWIG_AsVal_int(PyObject *obj, int *val)
1763 {
1764 return SWIG_AsVal_long(obj,(long*)val);
1765 }
1766 #endif
1767
1768
1769 SWIGINTERNSHORT int
1770 SWIG_As_int(PyObject* obj)
1771 {
1772 int v;
1773 if (!SWIG_AsVal_int(obj, &v)) {
1774 /*
1775 this is needed to make valgrind/purify happier.
1776 */
1777 memset((void*)&v, 0, sizeof(int));
1778 }
1779 return v;
1780 }
1781
1782
1783 SWIGINTERNSHORT int
1784 SWIG_Check_int(PyObject* obj)
1785 {
1786 return SWIG_AsVal_int(obj, (int*)0);
1787 }
1788
1789 static PyObject *wxSize_Get(wxSize *self){
1790 bool blocked = wxPyBeginBlockThreads();
1791 PyObject* tup = PyTuple_New(2);
1792 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1793 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1794 wxPyEndBlockThreads(blocked);
1795 return tup;
1796 }
1797
1798 SWIGINTERN int
1799 SWIG_AsVal_double(PyObject *obj, double* val)
1800 {
1801 if (PyNumber_Check(obj)) {
1802 if (val) *val = PyFloat_AsDouble(obj);
1803 return 1;
1804 }
1805 else {
1806 SWIG_type_error("number", obj);
1807 }
1808 return 0;
1809 }
1810
1811
1812 SWIGINTERNSHORT double
1813 SWIG_As_double(PyObject* obj)
1814 {
1815 double v;
1816 if (!SWIG_AsVal_double(obj, &v)) {
1817 /*
1818 this is needed to make valgrind/purify happier.
1819 */
1820 memset((void*)&v, 0, sizeof(double));
1821 }
1822 return v;
1823 }
1824
1825
1826 SWIGINTERNSHORT int
1827 SWIG_Check_double(PyObject* obj)
1828 {
1829 return SWIG_AsVal_double(obj, (double*)0);
1830 }
1831
1832
1833 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1834 #define SWIG_From_double PyFloat_FromDouble
1835 /*@@*/
1836
1837 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1838 self->x = x;
1839 self->y = y;
1840 }
1841 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1842 bool blocked = wxPyBeginBlockThreads();
1843 PyObject* tup = PyTuple_New(2);
1844 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1845 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1846 wxPyEndBlockThreads(blocked);
1847 return tup;
1848 }
1849
1850 SWIGINTERNSHORT long
1851 SWIG_As_long(PyObject* obj)
1852 {
1853 long v;
1854 if (!SWIG_AsVal_long(obj, &v)) {
1855 /*
1856 this is needed to make valgrind/purify happier.
1857 */
1858 memset((void*)&v, 0, sizeof(long));
1859 }
1860 return v;
1861 }
1862
1863
1864 SWIGINTERNSHORT int
1865 SWIG_Check_long(PyObject* obj)
1866 {
1867 return SWIG_AsVal_long(obj, (long*)0);
1868 }
1869
1870 static void wxPoint_Set(wxPoint *self,long x,long y){
1871 self->x = x;
1872 self->y = y;
1873 }
1874 static PyObject *wxPoint_Get(wxPoint *self){
1875 bool blocked = wxPyBeginBlockThreads();
1876 PyObject* tup = PyTuple_New(2);
1877 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1878 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1879 wxPyEndBlockThreads(blocked);
1880 return tup;
1881 }
1882 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1883 self->x = x;
1884 self->y = y;
1885 self->width = width;
1886 self->height = height;
1887 }
1888 static PyObject *wxRect_Get(wxRect *self){
1889 bool blocked = wxPyBeginBlockThreads();
1890 PyObject* tup = PyTuple_New(4);
1891 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1892 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1893 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1894 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1895 wxPyEndBlockThreads(blocked);
1896 return tup;
1897 }
1898
1899 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1900 wxRegion reg1(*r1);
1901 wxRegion reg2(*r2);
1902 wxRect dest(0,0,0,0);
1903 PyObject* obj;
1904
1905 reg1.Intersect(reg2);
1906 dest = reg1.GetBox();
1907
1908 if (dest != wxRect(0,0,0,0)) {
1909 bool blocked = wxPyBeginBlockThreads();
1910 wxRect* newRect = new wxRect(dest);
1911 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1912 wxPyEndBlockThreads(blocked);
1913 return obj;
1914 }
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918
1919
1920 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1921 PyObject* o2;
1922 PyObject* o3;
1923
1924 if (!target) {
1925 target = o;
1926 } else if (target == Py_None) {
1927 Py_DECREF(Py_None);
1928 target = o;
1929 } else {
1930 if (!PyTuple_Check(target)) {
1931 o2 = target;
1932 target = PyTuple_New(1);
1933 PyTuple_SetItem(target, 0, o2);
1934 }
1935 o3 = PyTuple_New(1);
1936 PyTuple_SetItem(o3, 0, o);
1937
1938 o2 = target;
1939 target = PySequence_Concat(o2, o3);
1940 Py_DECREF(o2);
1941 Py_DECREF(o3);
1942 }
1943 return target;
1944 }
1945
1946
1947 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1948 self->m_x = x;
1949 self->m_y = y;
1950 }
1951 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1952 bool blocked = wxPyBeginBlockThreads();
1953 PyObject* tup = PyTuple_New(2);
1954 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1955 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1956 wxPyEndBlockThreads(blocked);
1957 return tup;
1958 }
1959
1960 #include "wx/wxPython/pyistream.h"
1961
1962 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1963 wxInputStream* wxis = wxPyCBInputStream::create(p);
1964 if (wxis)
1965 return new wxPyInputStream(wxis);
1966 else
1967 return NULL;
1968 }
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_char(char c)
1972 {
1973 return PyString_FromStringAndSize(&c,1);
1974 }
1975
1976
1977 SWIGINTERNSHORT PyObject*
1978 SWIG_From_unsigned_SS_long(unsigned long value)
1979 {
1980 return (value > LONG_MAX) ?
1981 PyLong_FromUnsignedLong(value)
1982 : PyInt_FromLong((long)(value));
1983 }
1984
1985
1986 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1987 SWIGINTERN int
1988 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1989 {
1990 static swig_type_info* pchar_info = 0;
1991 char* vptr = 0;
1992 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1993 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1994 if (cptr) *cptr = vptr;
1995 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1996 return SWIG_OLDOBJ;
1997 } else {
1998 PyErr_Clear();
1999 if (PyString_Check(obj)) {
2000 if (cptr) {
2001 *cptr = PyString_AS_STRING(obj);
2002 if (psize) {
2003 *psize = PyString_GET_SIZE(obj) + 1;
2004 }
2005 }
2006 return SWIG_PYSTR;
2007 }
2008 }
2009 if (cptr) {
2010 SWIG_type_error("char *", obj);
2011 }
2012 return 0;
2013 }
2014
2015
2016 SWIGINTERN int
2017 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2018 {
2019 char* cptr; size_t csize;
2020 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2021 /* in C you can do:
2022
2023 char x[5] = "hello";
2024
2025 ie, assing the array using an extra '0' char.
2026 */
2027 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2028 if (csize <= size) {
2029 if (val) {
2030 if (csize) memcpy(val, cptr, csize);
2031 if (csize < size) memset(val + csize, 0, size - csize);
2032 }
2033 return 1;
2034 }
2035 }
2036 if (val) {
2037 PyErr_Format(PyExc_TypeError,
2038 "a char array of maximum size %lu is expected",
2039 (unsigned long) size);
2040 }
2041 return 0;
2042 }
2043
2044
2045 SWIGINTERN int
2046 SWIG_AsVal_char(PyObject *obj, char *val)
2047 {
2048 const char* errmsg = val ? "char" : (char*)0;
2049 long v;
2050 if (SWIG_AsVal_long(obj, &v)) {
2051 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2052 if (val) *val = (char)(v);
2053 return 1;
2054 } else {
2055 return 0;
2056 }
2057 } else {
2058 PyErr_Clear();
2059 return SWIG_AsCharArray(obj, val, 1);
2060 }
2061 }
2062
2063
2064 SWIGINTERNSHORT char
2065 SWIG_As_char(PyObject* obj)
2066 {
2067 char v;
2068 if (!SWIG_AsVal_char(obj, &v)) {
2069 /*
2070 this is needed to make valgrind/purify happier.
2071 */
2072 memset((void*)&v, 0, sizeof(char));
2073 }
2074 return v;
2075 }
2076
2077
2078 SWIGINTERNSHORT int
2079 SWIG_Check_char(PyObject* obj)
2080 {
2081 return SWIG_AsVal_char(obj, (char*)0);
2082 }
2083
2084
2085 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2086 #define SWIG_From_long PyInt_FromLong
2087 /*@@*/
2088
2089 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2090 // We use only strings for the streams, not unicode
2091 PyObject* str = PyObject_Str(obj);
2092 if (! str) {
2093 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2094 return;
2095 }
2096 self->Write(PyString_AS_STRING(str),
2097 PyString_GET_SIZE(str));
2098 Py_DECREF(str);
2099 }
2100
2101 #include "wx/wxPython/pyistream.h"
2102
2103
2104 class wxPyFileSystemHandler : public wxFileSystemHandler
2105 {
2106 public:
2107 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2108
2109 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2110 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2111 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2112 DEC_PYCALLBACK_STRING__pure(FindNext);
2113
2114 wxString GetProtocol(const wxString& location) {
2115 return wxFileSystemHandler::GetProtocol(location);
2116 }
2117
2118 wxString GetLeftLocation(const wxString& location) {
2119 return wxFileSystemHandler::GetLeftLocation(location);
2120 }
2121
2122 wxString GetAnchor(const wxString& location) {
2123 return wxFileSystemHandler::GetAnchor(location);
2124 }
2125
2126 wxString GetRightLocation(const wxString& location) {
2127 return wxFileSystemHandler::GetRightLocation(location);
2128 }
2129
2130 wxString GetMimeTypeFromExt(const wxString& location) {
2131 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2132 }
2133
2134 PYPRIVATE;
2135 };
2136
2137
2138 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2139 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2140 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2141 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2142
2143
2144 SWIGINTERN int
2145 SWIG_AsVal_bool(PyObject *obj, bool *val)
2146 {
2147 if (obj == Py_True) {
2148 if (val) *val = true;
2149 return 1;
2150 }
2151 if (obj == Py_False) {
2152 if (val) *val = false;
2153 return 1;
2154 }
2155 int res = 0;
2156 if (SWIG_AsVal_int(obj, &res)) {
2157 if (val) *val = res ? true : false;
2158 return 1;
2159 } else {
2160 PyErr_Clear();
2161 }
2162 if (val) {
2163 SWIG_type_error("bool", obj);
2164 }
2165 return 0;
2166 }
2167
2168
2169 SWIGINTERNSHORT bool
2170 SWIG_As_bool(PyObject* obj)
2171 {
2172 bool v;
2173 if (!SWIG_AsVal_bool(obj, &v)) {
2174 /*
2175 this is needed to make valgrind/purify happier.
2176 */
2177 memset((void*)&v, 0, sizeof(bool));
2178 }
2179 return v;
2180 }
2181
2182
2183 SWIGINTERNSHORT int
2184 SWIG_Check_bool(PyObject* obj)
2185 {
2186 return SWIG_AsVal_bool(obj, (bool*)0);
2187 }
2188
2189 static wxString FileSystem_URLToFileName(wxString const &url){
2190 wxFileName fname = wxFileSystem::URLToFileName(url);
2191 return fname.GetFullPath();
2192 }
2193
2194 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2195 wxImage& image,
2196 long type) {
2197 wxMemoryFSHandler::AddFile(filename, image, type);
2198 }
2199
2200 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2201 const wxBitmap& bitmap,
2202 long type) {
2203 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2204 }
2205
2206 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2207 PyObject* data) {
2208 if (! PyString_Check(data)) {
2209 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2210 "Expected string object"));
2211 return;
2212 }
2213
2214 bool blocked = wxPyBeginBlockThreads();
2215 void* ptr = (void*)PyString_AsString(data);
2216 size_t size = PyString_Size(data);
2217 wxPyEndBlockThreads(blocked);
2218
2219 wxMemoryFSHandler::AddFile(filename, ptr, size);
2220 }
2221
2222
2223 #include "wx/wxPython/pyistream.h"
2224
2225
2226 SWIGINTERN int
2227 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2228 {
2229 long v = 0;
2230 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2231 SWIG_type_error("unsigned number", obj);
2232 }
2233 else if (val)
2234 *val = (unsigned long)v;
2235 return 1;
2236 }
2237
2238
2239 SWIGINTERNSHORT int
2240 SWIG_CheckUnsignedLongInRange(unsigned long value,
2241 unsigned long max_value,
2242 const char *errmsg)
2243 {
2244 if (value > max_value) {
2245 if (errmsg) {
2246 PyErr_Format(PyExc_OverflowError,
2247 "value %lu is greater than '%s' minimum %lu",
2248 value, errmsg, max_value);
2249 }
2250 return 0;
2251 }
2252 return 1;
2253 }
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2258 {
2259 const char* errmsg = val ? "unsigned char" : (char*)0;
2260 unsigned long v;
2261 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2262 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2263 if (val) *val = (unsigned char)(v);
2264 return 1;
2265 } else {
2266 return 0;
2267 }
2268 } else {
2269 PyErr_Clear();
2270 }
2271 if (val) {
2272 SWIG_type_error(errmsg, obj);
2273 }
2274 return 0;
2275 }
2276
2277
2278 SWIGINTERNSHORT unsigned char
2279 SWIG_As_unsigned_SS_char(PyObject* obj)
2280 {
2281 unsigned char v;
2282 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2283 /*
2284 this is needed to make valgrind/purify happier.
2285 */
2286 memset((void*)&v, 0, sizeof(unsigned char));
2287 }
2288 return v;
2289 }
2290
2291
2292 SWIGINTERNSHORT int
2293 SWIG_Check_unsigned_SS_char(PyObject* obj)
2294 {
2295 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2296 }
2297
2298
2299 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2300 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2301 /*@@*/
2302
2303
2304 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2305 if (width > 0 && height > 0)
2306 return new wxImage(width, height, clear);
2307 else
2308 return new wxImage;
2309 }
2310 static wxImage *new_wxImage(wxBitmap const &bitmap){
2311 return new wxImage(bitmap.ConvertToImage());
2312 }
2313 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2314 // Copy the source data so the wxImage can clean it up later
2315 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2316 if (copy == NULL) {
2317 PyErr_NoMemory();
2318 return NULL;
2319 }
2320 memcpy(copy, data, width*height*3);
2321 return new wxImage(width, height, copy, false);
2322 }
2323 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2324 // Copy the source data so the wxImage can clean it up later
2325 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2326 if (dcopy == NULL) {
2327 PyErr_NoMemory();
2328 return NULL;
2329 }
2330 memcpy(dcopy, data, width*height*3);
2331 unsigned char* acopy = (unsigned char*)malloc(width*height);
2332 if (acopy == NULL) {
2333 PyErr_NoMemory();
2334 return NULL;
2335 }
2336 memcpy(acopy, alpha, width*height);
2337
2338 return new wxImage(width, height, dcopy, acopy, false);
2339 }
2340 static wxSize wxImage_GetSize(wxImage *self){
2341 wxSize size(self->GetWidth(), self->GetHeight());
2342 return size;
2343 }
2344 static PyObject *wxImage_GetData(wxImage *self){
2345 unsigned char* data = self->GetData();
2346 int len = self->GetWidth() * self->GetHeight() * 3;
2347 PyObject* rv;
2348 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2349 return rv;
2350 }
2351 static void wxImage_SetData(wxImage *self,PyObject *data){
2352 unsigned char* dataPtr;
2353
2354 if (! PyString_Check(data)) {
2355 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2356 "Expected string object"));
2357 return /* NULL */ ;
2358 }
2359
2360 size_t len = self->GetWidth() * self->GetHeight() * 3;
2361 dataPtr = (unsigned char*) malloc(len);
2362 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2363 self->SetData(dataPtr);
2364 // wxImage takes ownership of dataPtr...
2365 }
2366 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2367 unsigned char* data = self->GetData();
2368 int len = self->GetWidth() * self->GetHeight() * 3;
2369 PyObject* rv;
2370 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2371 return rv;
2372 }
2373 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2374 unsigned char* buffer;
2375 int size;
2376
2377 bool blocked = wxPyBeginBlockThreads();
2378 if (!PyArg_Parse(data, "t#", &buffer, &size))
2379 goto done;
2380
2381 if (size != self->GetWidth() * self->GetHeight() * 3) {
2382 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2383 goto done;
2384 }
2385 self->SetData(buffer);
2386 done:
2387 wxPyEndBlockThreads(blocked);
2388 }
2389 static PyObject *wxImage_GetAlphaData(wxImage *self){
2390 unsigned char* data = self->GetAlpha();
2391 if (! data) {
2392 RETURN_NONE();
2393 } else {
2394 int len = self->GetWidth() * self->GetHeight();
2395 PyObject* rv;
2396 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2397 return rv;
2398 }
2399 }
2400 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2401 unsigned char* dataPtr;
2402
2403 if (! PyString_Check(data)) {
2404 PyErr_SetString(PyExc_TypeError, "Expected string object");
2405 return /* NULL */ ;
2406 }
2407
2408 size_t len = self->GetWidth() * self->GetHeight();
2409 dataPtr = (unsigned char*) malloc(len);
2410 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2411 self->SetAlpha(dataPtr);
2412 // wxImage takes ownership of dataPtr...
2413 }
2414 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2415 unsigned char* data = self->GetAlpha();
2416 int len = self->GetWidth() * self->GetHeight();
2417 PyObject* rv;
2418 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2419 return rv;
2420 }
2421 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2422 unsigned char* buffer;
2423 int size;
2424
2425 bool blocked = wxPyBeginBlockThreads();
2426 if (!PyArg_Parse(data, "t#", &buffer, &size))
2427 goto done;
2428
2429 if (size != self->GetWidth() * self->GetHeight()) {
2430 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2431 goto done;
2432 }
2433 self->SetAlpha(buffer);
2434 done:
2435 wxPyEndBlockThreads(blocked);
2436 }
2437
2438 SWIGINTERNSHORT unsigned long
2439 SWIG_As_unsigned_SS_long(PyObject* obj)
2440 {
2441 unsigned long v;
2442 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2443 /*
2444 this is needed to make valgrind/purify happier.
2445 */
2446 memset((void*)&v, 0, sizeof(unsigned long));
2447 }
2448 return v;
2449 }
2450
2451
2452 SWIGINTERNSHORT int
2453 SWIG_Check_unsigned_SS_long(PyObject* obj)
2454 {
2455 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2456 }
2457
2458 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2459 wxBitmap bitmap(*self, depth);
2460 return bitmap;
2461 }
2462 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2463 wxImage mono = self->ConvertToMono( red, green, blue );
2464 wxBitmap bitmap( mono, 1 );
2465 return bitmap;
2466 }
2467 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2468 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2470 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2474 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2475 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2476 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2477 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2478 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2479 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2480 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2481 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2482
2483 #include <wx/quantize.h>
2484
2485 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2486 return wxQuantize::Quantize(src, dest,
2487 //NULL, // palette
2488 desiredNoColours,
2489 NULL, // eightBitData
2490 flags);
2491 }
2492 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2493 if (PyCallable_Check(func)) {
2494 self->Connect(id, lastId, eventType,
2495 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2496 new wxPyCallback(func));
2497 }
2498 else if (func == Py_None) {
2499 self->Disconnect(id, lastId, eventType,
2500 (wxObjectEventFunction)
2501 &wxPyCallback::EventThunker);
2502 }
2503 else {
2504 wxPyBLOCK_THREADS(
2505 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2506 }
2507 }
2508 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2509 return self->Disconnect(id, lastId, eventType,
2510 (wxObjectEventFunction)
2511 &wxPyCallback::EventThunker);
2512 }
2513 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2514 if (_self && _self != Py_None) {
2515 self->SetClientObject(new wxPyOORClientData(_self, incref));
2516 }
2517 else {
2518 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2519 if (data) {
2520 self->SetClientObject(NULL); // This will delete it too
2521 }
2522 }
2523 }
2524
2525 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2526 #if wxUSE_UNICODE
2527 return self->GetUnicodeKey();
2528 #else
2529 return 0;
2530 #endif
2531 }
2532
2533 #if UINT_MAX < LONG_MAX
2534 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_long
2536 /*@@*/
2537 #else
2538 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2539 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2540 /*@@*/
2541 #endif
2542
2543
2544 #if UINT_MAX != ULONG_MAX
2545 SWIGINTERN int
2546 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2547 {
2548 const char* errmsg = val ? "unsigned int" : (char*)0;
2549 unsigned long v;
2550 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2551 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2552 if (val) *val = (unsigned int)(v);
2553 return 1;
2554 }
2555 } else {
2556 PyErr_Clear();
2557 }
2558 if (val) {
2559 SWIG_type_error(errmsg, obj);
2560 }
2561 return 0;
2562 }
2563 #else
2564 SWIGINTERNSHORT unsigned int
2565 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2566 {
2567 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2568 }
2569 #endif
2570
2571
2572 SWIGINTERNSHORT unsigned int
2573 SWIG_As_unsigned_SS_int(PyObject* obj)
2574 {
2575 unsigned int v;
2576 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2577 /*
2578 this is needed to make valgrind/purify happier.
2579 */
2580 memset((void*)&v, 0, sizeof(unsigned int));
2581 }
2582 return v;
2583 }
2584
2585
2586 SWIGINTERNSHORT int
2587 SWIG_Check_unsigned_SS_int(PyObject* obj)
2588 {
2589 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2590 }
2591
2592 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2593 self->m_size = size;
2594 }
2595 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2596 int count = self->GetNumberOfFiles();
2597 wxString* files = self->GetFiles();
2598 PyObject* list = PyList_New(count);
2599
2600 if (!list) {
2601 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2602 return NULL;
2603 }
2604
2605 for (int i=0; i<count; i++) {
2606 PyList_SetItem(list, i, wx2PyString(files[i]));
2607 }
2608 return list;
2609 }
2610
2611
2612 static wxPyApp *new_wxPyApp(){
2613 wxPythonApp = new wxPyApp();
2614 return wxPythonApp;
2615 }
2616
2617 void wxApp_CleanUp() {
2618 __wxPyCleanup();
2619 }
2620
2621
2622 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2623
2624
2625 SWIGINTERNSHORT int
2626 SWIG_AsCharPtr(PyObject *obj, char **val)
2627 {
2628 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2629 return 1;
2630 }
2631 if (val) {
2632 PyErr_Clear();
2633 SWIG_type_error("char *", obj);
2634 }
2635 return 0;
2636 }
2637
2638
2639 SWIGINTERN PyObject *
2640 SWIG_FromCharPtr(const char* cptr)
2641 {
2642 if (cptr) {
2643 size_t size = strlen(cptr);
2644 if (size > INT_MAX) {
2645 return SWIG_NewPointerObj((char*)(cptr),
2646 SWIG_TypeQuery("char *"), 0);
2647 } else {
2648 if (size != 0) {
2649 return PyString_FromStringAndSize(cptr, size);
2650 } else {
2651 return PyString_FromString(cptr);
2652 }
2653 }
2654 }
2655 Py_INCREF(Py_None);
2656 return Py_None;
2657 }
2658
2659
2660 #ifdef __WXMAC__
2661
2662 // A dummy class that raises an exception if used...
2663 class wxEventLoop
2664 {
2665 public:
2666 wxEventLoop() { wxPyRaiseNotImplemented(); }
2667 int Run() { return 0; }
2668 void Exit(int rc = 0) {}
2669 bool Pending() const { return false; }
2670 bool Dispatch() { return false; }
2671 bool IsRunning() const { return false; }
2672 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2673 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2674 };
2675
2676 #else
2677
2678 #include <wx/evtloop.h>
2679
2680 #endif
2681
2682
2683
2684 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2685 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2686 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2687 static PyObject *wxWindow_GetChildren(wxWindow *self){
2688 wxWindowList& list = self->GetChildren();
2689 return wxPy_ConvertList(&list);
2690 }
2691 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2692 #if wxUSE_HOTKEY
2693 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2694 #else
2695 return false;
2696 #endif
2697 }
2698 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2699
2700
2701
2702 return false;
2703
2704 }
2705 static long wxWindow_GetHandle(wxWindow *self){
2706 return wxPyGetWinHandle(self);
2707 }
2708 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2709 self->AssociateHandle((WXWidget)handle);
2710 }
2711
2712 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2713 return wxWindow::FindWindowById(id, parent);
2714 }
2715
2716 wxWindow* wxFindWindowByName( const wxString& name,
2717 const wxWindow *parent = NULL ) {
2718 return wxWindow::FindWindowByName(name, parent);
2719 }
2720
2721 wxWindow* wxFindWindowByLabel( const wxString& label,
2722 const wxWindow *parent = NULL ) {
2723 return wxWindow::FindWindowByLabel(label, parent);
2724 }
2725
2726
2727 #ifdef __WXMSW__
2728 #include <wx/msw/private.h> // to get wxGetWindowId
2729 #endif
2730
2731
2732 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2733 #ifdef __WXMSW__
2734 WXHWND hWnd = (WXHWND)_hWnd;
2735 long id = wxGetWindowId(hWnd);
2736 wxWindow* win = new wxWindow;
2737 parent->AddChild(win);
2738 win->SetEventHandler(win);
2739 win->SetHWND(hWnd);
2740 win->SetId(id);
2741 win->SubclassWin(hWnd);
2742 win->AdoptAttributesFromHWND();
2743 win->SetupColours();
2744 return win;
2745 #else
2746 wxPyRaiseNotImplemented();
2747 return NULL;
2748 #endif
2749 }
2750
2751
2752 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2753 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2754 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2755
2756 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2757
2758 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2759 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2760 wxMenuItemList& list = self->GetMenuItems();
2761 return wxPy_ConvertList(&list);
2762 }
2763 static const wxString wxPyControlNameStr(wxControlNameStr);
2764 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2765 if (clientData) {
2766 wxPyClientData* data = new wxPyClientData(clientData);
2767 return self->Append(item, data);
2768 } else
2769 return self->Append(item);
2770 }
2771 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2772 if (clientData) {
2773 wxPyClientData* data = new wxPyClientData(clientData);
2774 return self->Insert(item, pos, data);
2775 } else
2776 return self->Insert(item, pos);
2777 }
2778 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2779 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2780 if (data) {
2781 Py_INCREF(data->m_obj);
2782 return data->m_obj;
2783 } else {
2784 Py_INCREF(Py_None);
2785 return Py_None;
2786 }
2787 }
2788 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2789 wxPyClientData* data = new wxPyClientData(clientData);
2790 self->SetClientObject(n, data);
2791 }
2792
2793
2794 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2795 wxPyUserData* data = NULL;
2796 if ( userData ) {
2797 bool blocked = wxPyBeginBlockThreads();
2798 data = new wxPyUserData(userData);
2799 wxPyEndBlockThreads(blocked);
2800 }
2801 return new wxSizerItem(window, proportion, flag, border, data);
2802 }
2803 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2804 wxPyUserData* data = NULL;
2805 if ( userData ) {
2806 bool blocked = wxPyBeginBlockThreads();
2807 data = new wxPyUserData(userData);
2808 wxPyEndBlockThreads(blocked);
2809 }
2810 return new wxSizerItem(width, height, proportion, flag, border, data);
2811 }
2812 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2813 wxPyUserData* data = NULL;
2814 if ( userData ) {
2815 bool blocked = wxPyBeginBlockThreads();
2816 data = new wxPyUserData(userData);
2817 wxPyEndBlockThreads(blocked);
2818 }
2819 return new wxSizerItem(sizer, proportion, flag, border, data);
2820 }
2821
2822 #include <float.h>
2823 SWIGINTERN int
2824 SWIG_CheckDoubleInRange(double value, double min_value,
2825 double max_value, const char* errmsg)
2826 {
2827 if (value < min_value) {
2828 if (errmsg) {
2829 PyErr_Format(PyExc_OverflowError,
2830 "value %g is less than %s minimum %g",
2831 value, errmsg, min_value);
2832 }
2833 return 0;
2834 } else if (value > max_value) {
2835 if (errmsg) {
2836 PyErr_Format(PyExc_OverflowError,
2837 "value %g is greater than %s maximum %g",
2838 value, errmsg, max_value);
2839 }
2840 return 0;
2841 }
2842 return 1;
2843 }
2844
2845
2846 SWIGINTERN int
2847 SWIG_AsVal_float(PyObject *obj, float *val)
2848 {
2849 const char* errmsg = val ? "float" : (char*)0;
2850 double v;
2851 if (SWIG_AsVal_double(obj, &v)) {
2852 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2853 if (val) *val = (float)(v);
2854 return 1;
2855 } else {
2856 return 0;
2857 }
2858 } else {
2859 PyErr_Clear();
2860 }
2861 if (val) {
2862 SWIG_type_error(errmsg, obj);
2863 }
2864 return 0;
2865 }
2866
2867
2868 SWIGINTERNSHORT float
2869 SWIG_As_float(PyObject* obj)
2870 {
2871 float v;
2872 if (!SWIG_AsVal_float(obj, &v)) {
2873 /*
2874 this is needed to make valgrind/purify happier.
2875 */
2876 memset((void*)&v, 0, sizeof(float));
2877 }
2878 return v;
2879 }
2880
2881
2882 SWIGINTERNSHORT int
2883 SWIG_Check_float(PyObject* obj)
2884 {
2885 return SWIG_AsVal_float(obj, (float*)0);
2886 }
2887
2888
2889 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2890 #define SWIG_From_float PyFloat_FromDouble
2891 /*@@*/
2892
2893 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2894 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2895 if (data) {
2896 Py_INCREF(data->m_obj);
2897 return data->m_obj;
2898 } else {
2899 Py_INCREF(Py_None);
2900 return Py_None;
2901 }
2902 }
2903
2904 // Figure out the type of the sizer item
2905
2906 struct wxPySizerItemInfo {
2907 wxPySizerItemInfo()
2908 : window(NULL), sizer(NULL), gotSize(false),
2909 size(wxDefaultSize), gotPos(false), pos(-1)
2910 {}
2911
2912 wxWindow* window;
2913 wxSizer* sizer;
2914 bool gotSize;
2915 wxSize size;
2916 bool gotPos;
2917 int pos;
2918 };
2919
2920 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2921
2922 wxPySizerItemInfo info;
2923 wxSize size;
2924 wxSize* sizePtr = &size;
2925
2926 // Find out what the type of the item is
2927 // try wxWindow
2928 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2929 PyErr_Clear();
2930 info.window = NULL;
2931
2932 // try wxSizer
2933 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2934 PyErr_Clear();
2935 info.sizer = NULL;
2936
2937 // try wxSize or (w,h)
2938 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2939 info.size = *sizePtr;
2940 info.gotSize = true;
2941 }
2942
2943 // or a single int
2944 if (checkIdx && PyInt_Check(item)) {
2945 info.pos = PyInt_AsLong(item);
2946 info.gotPos = true;
2947 }
2948 }
2949 }
2950
2951 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2952 // no expected type, figure out what kind of error message to generate
2953 if ( !checkSize && !checkIdx )
2954 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2955 else if ( checkSize && !checkIdx )
2956 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2957 else if ( !checkSize && checkIdx)
2958 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2959 else
2960 // can this one happen?
2961 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2962 }
2963
2964 return info;
2965 }
2966
2967 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2968 if (!self->GetClientObject())
2969 self->SetClientObject(new wxPyOORClientData(_self));
2970 }
2971 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2972
2973 wxPyUserData* data = NULL;
2974 bool blocked = wxPyBeginBlockThreads();
2975 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2976 if ( userData && (info.window || info.sizer || info.gotSize) )
2977 data = new wxPyUserData(userData);
2978 wxPyEndBlockThreads(blocked);
2979
2980 // Now call the real Add method if a valid item type was found
2981 if ( info.window )
2982 return self->Add(info.window, proportion, flag, border, data);
2983 else if ( info.sizer )
2984 return self->Add(info.sizer, proportion, flag, border, data);
2985 else if (info.gotSize)
2986 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2987 proportion, flag, border, data);
2988 else
2989 return NULL;
2990 }
2991 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2992
2993 wxPyUserData* data = NULL;
2994 bool blocked = wxPyBeginBlockThreads();
2995 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2996 if ( userData && (info.window || info.sizer || info.gotSize) )
2997 data = new wxPyUserData(userData);
2998 wxPyEndBlockThreads(blocked);
2999
3000 // Now call the real Insert method if a valid item type was found
3001 if ( info.window )
3002 return self->Insert(before, info.window, proportion, flag, border, data);
3003 else if ( info.sizer )
3004 return self->Insert(before, info.sizer, proportion, flag, border, data);
3005 else if (info.gotSize)
3006 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3007 proportion, flag, border, data);
3008 else
3009 return NULL;
3010 }
3011 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3012
3013 wxPyUserData* data = NULL;
3014 bool blocked = wxPyBeginBlockThreads();
3015 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3016 if ( userData && (info.window || info.sizer || info.gotSize) )
3017 data = new wxPyUserData(userData);
3018 wxPyEndBlockThreads(blocked);
3019
3020 // Now call the real Prepend method if a valid item type was found
3021 if ( info.window )
3022 return self->Prepend(info.window, proportion, flag, border, data);
3023 else if ( info.sizer )
3024 return self->Prepend(info.sizer, proportion, flag, border, data);
3025 else if (info.gotSize)
3026 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3027 proportion, flag, border, data);
3028 else
3029 return NULL;
3030 }
3031 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3032 bool blocked = wxPyBeginBlockThreads();
3033 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3034 wxPyEndBlockThreads(blocked);
3035 if ( info.window )
3036 return self->Remove(info.window);
3037 else if ( info.sizer )
3038 return self->Remove(info.sizer);
3039 else if ( info.gotPos )
3040 return self->Remove(info.pos);
3041 else
3042 return false;
3043 }
3044 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3045 bool blocked = wxPyBeginBlockThreads();
3046 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3047 wxPyEndBlockThreads(blocked);
3048 if ( info.window )
3049 return self->Detach(info.window);
3050 else if ( info.sizer )
3051 return self->Detach(info.sizer);
3052 else if ( info.gotPos )
3053 return self->Detach(info.pos);
3054 else
3055 return false;
3056 }
3057 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3058 bool blocked = wxPyBeginBlockThreads();
3059 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3060 wxPyEndBlockThreads(blocked);
3061 if ( info.window )
3062 return self->GetItem(info.window);
3063 else if ( info.sizer )
3064 return self->GetItem(info.sizer);
3065 else if ( info.gotPos )
3066 return self->GetItem(info.pos);
3067 else
3068 return NULL;
3069 }
3070 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3071 bool blocked = wxPyBeginBlockThreads();
3072 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3073 wxPyEndBlockThreads(blocked);
3074 if ( info.window )
3075 self->SetItemMinSize(info.window, size);
3076 else if ( info.sizer )
3077 self->SetItemMinSize(info.sizer, size);
3078 else if ( info.gotPos )
3079 self->SetItemMinSize(info.pos, size);
3080 }
3081 static PyObject *wxSizer_GetChildren(wxSizer *self){
3082 wxSizerItemList& list = self->GetChildren();
3083 return wxPy_ConvertList(&list);
3084 }
3085 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3086 bool blocked = wxPyBeginBlockThreads();
3087 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3088 wxPyEndBlockThreads(blocked);
3089 if ( info.window )
3090 return self->Show(info.window, show, recursive);
3091 else if ( info.sizer )
3092 return self->Show(info.sizer, show, recursive);
3093 else if ( info.gotPos )
3094 return self->Show(info.pos, show);
3095 else
3096 return false;
3097 }
3098 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3099 bool blocked = wxPyBeginBlockThreads();
3100 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3101 wxPyEndBlockThreads(blocked);
3102 if ( info.window )
3103 return self->IsShown(info.window);
3104 else if ( info.sizer )
3105 return self->IsShown(info.sizer);
3106 else if ( info.gotPos )
3107 return self->IsShown(info.pos);
3108 else
3109 return false;
3110 }
3111
3112 // See pyclasses.h
3113 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3114 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3115 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3116
3117
3118
3119
3120 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3121 {
3122 if (source == Py_None) {
3123 **obj = wxGBPosition(-1,-1);
3124 return true;
3125 }
3126 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3127 }
3128
3129 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3130 {
3131 if (source == Py_None) {
3132 **obj = wxGBSpan(-1,-1);
3133 return true;
3134 }
3135 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3136 }
3137
3138
3139 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3140 self->SetRow(row);
3141 self->SetCol(col);
3142 }
3143 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3144 bool blocked = wxPyBeginBlockThreads();
3145 PyObject* tup = PyTuple_New(2);
3146 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3147 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3148 wxPyEndBlockThreads(blocked);
3149 return tup;
3150 }
3151 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3152 self->SetRowspan(rowspan);
3153 self->SetColspan(colspan);
3154 }
3155 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3156 bool blocked = wxPyBeginBlockThreads();
3157 PyObject* tup = PyTuple_New(2);
3158 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3159 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3160 wxPyEndBlockThreads(blocked);
3161 return tup;
3162 }
3163 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3164 wxPyUserData* data = NULL;
3165 if ( userData ) {
3166 bool blocked = wxPyBeginBlockThreads();
3167 data = new wxPyUserData(userData);
3168 wxPyEndBlockThreads(blocked);
3169 }
3170 return new wxGBSizerItem(window, pos, span, flag, border, data);
3171 }
3172 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3173 wxPyUserData* data = NULL;
3174 if ( userData ) {
3175 bool blocked = wxPyBeginBlockThreads();
3176 data = new wxPyUserData(userData);
3177 wxPyEndBlockThreads(blocked);
3178 }
3179 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3180 }
3181 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3182 wxPyUserData* data = NULL;
3183 if ( userData ) {
3184 bool blocked = wxPyBeginBlockThreads();
3185 data = new wxPyUserData(userData);
3186 wxPyEndBlockThreads(blocked);
3187 }
3188 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3189 }
3190 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3191 int row, col;
3192 self->GetEndPos(row, col);
3193 return wxGBPosition(row, col);
3194 }
3195 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3196
3197 wxPyUserData* data = NULL;
3198 bool blocked = wxPyBeginBlockThreads();
3199 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3200 if ( userData && (info.window || info.sizer || info.gotSize) )
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203
3204 // Now call the real Add method if a valid item type was found
3205 if ( info.window )
3206 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3207 else if ( info.sizer )
3208 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3209 else if (info.gotSize)
3210 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3211 pos, span, flag, border, data);
3212 return NULL;
3213 }
3214
3215
3216 #ifdef __cplusplus
3217 extern "C" {
3218 #endif
3219 static int _wrap_EmptyString_set(PyObject *) {
3220 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3221 return 1;
3222 }
3223
3224
3225 static PyObject *_wrap_EmptyString_get(void) {
3226 PyObject *pyobj;
3227
3228 {
3229 #if wxUSE_UNICODE
3230 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3231 #else
3232 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3233 #endif
3234 }
3235 return pyobj;
3236 }
3237
3238
3239 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3240 PyObject *resultobj;
3241 wxObject *arg1 = (wxObject *) 0 ;
3242 wxString result;
3243 PyObject * obj0 = 0 ;
3244 char *kwnames[] = {
3245 (char *) "self", NULL
3246 };
3247
3248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3250 if (SWIG_arg_fail(1)) SWIG_fail;
3251 {
3252 PyThreadState* __tstate = wxPyBeginAllowThreads();
3253 result = wxObject_GetClassName(arg1);
3254
3255 wxPyEndAllowThreads(__tstate);
3256 if (PyErr_Occurred()) SWIG_fail;
3257 }
3258 {
3259 #if wxUSE_UNICODE
3260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3261 #else
3262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3263 #endif
3264 }
3265 return resultobj;
3266 fail:
3267 return NULL;
3268 }
3269
3270
3271 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxObject *arg1 = (wxObject *) 0 ;
3274 PyObject * obj0 = 0 ;
3275 char *kwnames[] = {
3276 (char *) "self", NULL
3277 };
3278
3279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3281 if (SWIG_arg_fail(1)) SWIG_fail;
3282 {
3283 PyThreadState* __tstate = wxPyBeginAllowThreads();
3284 wxObject_Destroy(arg1);
3285
3286 wxPyEndAllowThreads(__tstate);
3287 if (PyErr_Occurred()) SWIG_fail;
3288 }
3289 Py_INCREF(Py_None); resultobj = Py_None;
3290 return resultobj;
3291 fail:
3292 return NULL;
3293 }
3294
3295
3296 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3297 PyObject *obj;
3298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3299 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3300 Py_INCREF(obj);
3301 return Py_BuildValue((char *)"");
3302 }
3303 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3304 PyObject *resultobj;
3305 wxSize *arg1 = (wxSize *) 0 ;
3306 int arg2 ;
3307 PyObject * obj0 = 0 ;
3308 PyObject * obj1 = 0 ;
3309 char *kwnames[] = {
3310 (char *) "self",(char *) "x", NULL
3311 };
3312
3313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3315 if (SWIG_arg_fail(1)) SWIG_fail;
3316 {
3317 arg2 = (int)(SWIG_As_int(obj1));
3318 if (SWIG_arg_fail(2)) SWIG_fail;
3319 }
3320 if (arg1) (arg1)->x = arg2;
3321
3322 Py_INCREF(Py_None); resultobj = Py_None;
3323 return resultobj;
3324 fail:
3325 return NULL;
3326 }
3327
3328
3329 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3330 PyObject *resultobj;
3331 wxSize *arg1 = (wxSize *) 0 ;
3332 int result;
3333 PyObject * obj0 = 0 ;
3334 char *kwnames[] = {
3335 (char *) "self", NULL
3336 };
3337
3338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3340 if (SWIG_arg_fail(1)) SWIG_fail;
3341 result = (int) ((arg1)->x);
3342
3343 {
3344 resultobj = SWIG_From_int((int)(result));
3345 }
3346 return resultobj;
3347 fail:
3348 return NULL;
3349 }
3350
3351
3352 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3353 PyObject *resultobj;
3354 wxSize *arg1 = (wxSize *) 0 ;
3355 int arg2 ;
3356 PyObject * obj0 = 0 ;
3357 PyObject * obj1 = 0 ;
3358 char *kwnames[] = {
3359 (char *) "self",(char *) "y", NULL
3360 };
3361
3362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3364 if (SWIG_arg_fail(1)) SWIG_fail;
3365 {
3366 arg2 = (int)(SWIG_As_int(obj1));
3367 if (SWIG_arg_fail(2)) SWIG_fail;
3368 }
3369 if (arg1) (arg1)->y = arg2;
3370
3371 Py_INCREF(Py_None); resultobj = Py_None;
3372 return resultobj;
3373 fail:
3374 return NULL;
3375 }
3376
3377
3378 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3379 PyObject *resultobj;
3380 wxSize *arg1 = (wxSize *) 0 ;
3381 int result;
3382 PyObject * obj0 = 0 ;
3383 char *kwnames[] = {
3384 (char *) "self", NULL
3385 };
3386
3387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3389 if (SWIG_arg_fail(1)) SWIG_fail;
3390 result = (int) ((arg1)->y);
3391
3392 {
3393 resultobj = SWIG_From_int((int)(result));
3394 }
3395 return resultobj;
3396 fail:
3397 return NULL;
3398 }
3399
3400
3401 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3402 PyObject *resultobj;
3403 int arg1 = (int) 0 ;
3404 int arg2 = (int) 0 ;
3405 wxSize *result;
3406 PyObject * obj0 = 0 ;
3407 PyObject * obj1 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "w",(char *) "h", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3413 if (obj0) {
3414 {
3415 arg1 = (int)(SWIG_As_int(obj0));
3416 if (SWIG_arg_fail(1)) SWIG_fail;
3417 }
3418 }
3419 if (obj1) {
3420 {
3421 arg2 = (int)(SWIG_As_int(obj1));
3422 if (SWIG_arg_fail(2)) SWIG_fail;
3423 }
3424 }
3425 {
3426 PyThreadState* __tstate = wxPyBeginAllowThreads();
3427 result = (wxSize *)new wxSize(arg1,arg2);
3428
3429 wxPyEndAllowThreads(__tstate);
3430 if (PyErr_Occurred()) SWIG_fail;
3431 }
3432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3433 return resultobj;
3434 fail:
3435 return NULL;
3436 }
3437
3438
3439 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3440 PyObject *resultobj;
3441 wxSize *arg1 = (wxSize *) 0 ;
3442 PyObject * obj0 = 0 ;
3443 char *kwnames[] = {
3444 (char *) "self", NULL
3445 };
3446
3447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3449 if (SWIG_arg_fail(1)) SWIG_fail;
3450 {
3451 PyThreadState* __tstate = wxPyBeginAllowThreads();
3452 delete arg1;
3453
3454 wxPyEndAllowThreads(__tstate);
3455 if (PyErr_Occurred()) SWIG_fail;
3456 }
3457 Py_INCREF(Py_None); resultobj = Py_None;
3458 return resultobj;
3459 fail:
3460 return NULL;
3461 }
3462
3463
3464 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3465 PyObject *resultobj;
3466 wxSize *arg1 = (wxSize *) 0 ;
3467 wxSize *arg2 = 0 ;
3468 bool result;
3469 wxSize temp2 ;
3470 PyObject * obj0 = 0 ;
3471 PyObject * obj1 = 0 ;
3472 char *kwnames[] = {
3473 (char *) "self",(char *) "sz", NULL
3474 };
3475
3476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3478 if (SWIG_arg_fail(1)) SWIG_fail;
3479 {
3480 arg2 = &temp2;
3481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3482 }
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 {
3491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3492 }
3493 return resultobj;
3494 fail:
3495 return NULL;
3496 }
3497
3498
3499 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3500 PyObject *resultobj;
3501 wxSize *arg1 = (wxSize *) 0 ;
3502 wxSize *arg2 = 0 ;
3503 bool result;
3504 wxSize temp2 ;
3505 PyObject * obj0 = 0 ;
3506 PyObject * obj1 = 0 ;
3507 char *kwnames[] = {
3508 (char *) "self",(char *) "sz", NULL
3509 };
3510
3511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3513 if (SWIG_arg_fail(1)) SWIG_fail;
3514 {
3515 arg2 = &temp2;
3516 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3517 }
3518 {
3519 PyThreadState* __tstate = wxPyBeginAllowThreads();
3520 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3521
3522 wxPyEndAllowThreads(__tstate);
3523 if (PyErr_Occurred()) SWIG_fail;
3524 }
3525 {
3526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3527 }
3528 return resultobj;
3529 fail:
3530 return NULL;
3531 }
3532
3533
3534 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3535 PyObject *resultobj;
3536 wxSize *arg1 = (wxSize *) 0 ;
3537 wxSize *arg2 = 0 ;
3538 wxSize result;
3539 wxSize temp2 ;
3540 PyObject * obj0 = 0 ;
3541 PyObject * obj1 = 0 ;
3542 char *kwnames[] = {
3543 (char *) "self",(char *) "sz", NULL
3544 };
3545
3546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3548 if (SWIG_arg_fail(1)) SWIG_fail;
3549 {
3550 arg2 = &temp2;
3551 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3552 }
3553 {
3554 PyThreadState* __tstate = wxPyBeginAllowThreads();
3555 result = (arg1)->operator +((wxSize const &)*arg2);
3556
3557 wxPyEndAllowThreads(__tstate);
3558 if (PyErr_Occurred()) SWIG_fail;
3559 }
3560 {
3561 wxSize * resultptr;
3562 resultptr = new wxSize((wxSize &)(result));
3563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3564 }
3565 return resultobj;
3566 fail:
3567 return NULL;
3568 }
3569
3570
3571 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3572 PyObject *resultobj;
3573 wxSize *arg1 = (wxSize *) 0 ;
3574 wxSize *arg2 = 0 ;
3575 wxSize result;
3576 wxSize temp2 ;
3577 PyObject * obj0 = 0 ;
3578 PyObject * obj1 = 0 ;
3579 char *kwnames[] = {
3580 (char *) "self",(char *) "sz", NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3585 if (SWIG_arg_fail(1)) SWIG_fail;
3586 {
3587 arg2 = &temp2;
3588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3589 }
3590 {
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 result = (arg1)->operator -((wxSize const &)*arg2);
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 {
3598 wxSize * resultptr;
3599 resultptr = new wxSize((wxSize &)(result));
3600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3601 }
3602 return resultobj;
3603 fail:
3604 return NULL;
3605 }
3606
3607
3608 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj;
3610 wxSize *arg1 = (wxSize *) 0 ;
3611 wxSize *arg2 = 0 ;
3612 wxSize temp2 ;
3613 PyObject * obj0 = 0 ;
3614 PyObject * obj1 = 0 ;
3615 char *kwnames[] = {
3616 (char *) "self",(char *) "sz", NULL
3617 };
3618
3619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3621 if (SWIG_arg_fail(1)) SWIG_fail;
3622 {
3623 arg2 = &temp2;
3624 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3625 }
3626 {
3627 PyThreadState* __tstate = wxPyBeginAllowThreads();
3628 (arg1)->IncTo((wxSize const &)*arg2);
3629
3630 wxPyEndAllowThreads(__tstate);
3631 if (PyErr_Occurred()) SWIG_fail;
3632 }
3633 Py_INCREF(Py_None); resultobj = Py_None;
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3641 PyObject *resultobj;
3642 wxSize *arg1 = (wxSize *) 0 ;
3643 wxSize *arg2 = 0 ;
3644 wxSize temp2 ;
3645 PyObject * obj0 = 0 ;
3646 PyObject * obj1 = 0 ;
3647 char *kwnames[] = {
3648 (char *) "self",(char *) "sz", NULL
3649 };
3650
3651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 {
3655 arg2 = &temp2;
3656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3657 }
3658 {
3659 PyThreadState* __tstate = wxPyBeginAllowThreads();
3660 (arg1)->DecTo((wxSize const &)*arg2);
3661
3662 wxPyEndAllowThreads(__tstate);
3663 if (PyErr_Occurred()) SWIG_fail;
3664 }
3665 Py_INCREF(Py_None); resultobj = Py_None;
3666 return resultobj;
3667 fail:
3668 return NULL;
3669 }
3670
3671
3672 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3673 PyObject *resultobj;
3674 wxSize *arg1 = (wxSize *) 0 ;
3675 int arg2 ;
3676 int arg3 ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 PyObject * obj2 = 0 ;
3680 char *kwnames[] = {
3681 (char *) "self",(char *) "w",(char *) "h", NULL
3682 };
3683
3684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3686 if (SWIG_arg_fail(1)) SWIG_fail;
3687 {
3688 arg2 = (int)(SWIG_As_int(obj1));
3689 if (SWIG_arg_fail(2)) SWIG_fail;
3690 }
3691 {
3692 arg3 = (int)(SWIG_As_int(obj2));
3693 if (SWIG_arg_fail(3)) SWIG_fail;
3694 }
3695 {
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 (arg1)->Set(arg2,arg3);
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 Py_INCREF(Py_None); resultobj = Py_None;
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 wxSize *arg1 = (wxSize *) 0 ;
3712 int arg2 ;
3713 PyObject * obj0 = 0 ;
3714 PyObject * obj1 = 0 ;
3715 char *kwnames[] = {
3716 (char *) "self",(char *) "w", NULL
3717 };
3718
3719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3721 if (SWIG_arg_fail(1)) SWIG_fail;
3722 {
3723 arg2 = (int)(SWIG_As_int(obj1));
3724 if (SWIG_arg_fail(2)) SWIG_fail;
3725 }
3726 {
3727 PyThreadState* __tstate = wxPyBeginAllowThreads();
3728 (arg1)->SetWidth(arg2);
3729
3730 wxPyEndAllowThreads(__tstate);
3731 if (PyErr_Occurred()) SWIG_fail;
3732 }
3733 Py_INCREF(Py_None); resultobj = Py_None;
3734 return resultobj;
3735 fail:
3736 return NULL;
3737 }
3738
3739
3740 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3741 PyObject *resultobj;
3742 wxSize *arg1 = (wxSize *) 0 ;
3743 int arg2 ;
3744 PyObject * obj0 = 0 ;
3745 PyObject * obj1 = 0 ;
3746 char *kwnames[] = {
3747 (char *) "self",(char *) "h", NULL
3748 };
3749
3750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3752 if (SWIG_arg_fail(1)) SWIG_fail;
3753 {
3754 arg2 = (int)(SWIG_As_int(obj1));
3755 if (SWIG_arg_fail(2)) SWIG_fail;
3756 }
3757 {
3758 PyThreadState* __tstate = wxPyBeginAllowThreads();
3759 (arg1)->SetHeight(arg2);
3760
3761 wxPyEndAllowThreads(__tstate);
3762 if (PyErr_Occurred()) SWIG_fail;
3763 }
3764 Py_INCREF(Py_None); resultobj = Py_None;
3765 return resultobj;
3766 fail:
3767 return NULL;
3768 }
3769
3770
3771 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3772 PyObject *resultobj;
3773 wxSize *arg1 = (wxSize *) 0 ;
3774 int result;
3775 PyObject * obj0 = 0 ;
3776 char *kwnames[] = {
3777 (char *) "self", NULL
3778 };
3779
3780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3782 if (SWIG_arg_fail(1)) SWIG_fail;
3783 {
3784 PyThreadState* __tstate = wxPyBeginAllowThreads();
3785 result = (int)((wxSize const *)arg1)->GetWidth();
3786
3787 wxPyEndAllowThreads(__tstate);
3788 if (PyErr_Occurred()) SWIG_fail;
3789 }
3790 {
3791 resultobj = SWIG_From_int((int)(result));
3792 }
3793 return resultobj;
3794 fail:
3795 return NULL;
3796 }
3797
3798
3799 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3800 PyObject *resultobj;
3801 wxSize *arg1 = (wxSize *) 0 ;
3802 int result;
3803 PyObject * obj0 = 0 ;
3804 char *kwnames[] = {
3805 (char *) "self", NULL
3806 };
3807
3808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3810 if (SWIG_arg_fail(1)) SWIG_fail;
3811 {
3812 PyThreadState* __tstate = wxPyBeginAllowThreads();
3813 result = (int)((wxSize const *)arg1)->GetHeight();
3814
3815 wxPyEndAllowThreads(__tstate);
3816 if (PyErr_Occurred()) SWIG_fail;
3817 }
3818 {
3819 resultobj = SWIG_From_int((int)(result));
3820 }
3821 return resultobj;
3822 fail:
3823 return NULL;
3824 }
3825
3826
3827 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3828 PyObject *resultobj;
3829 wxSize *arg1 = (wxSize *) 0 ;
3830 bool result;
3831 PyObject * obj0 = 0 ;
3832 char *kwnames[] = {
3833 (char *) "self", NULL
3834 };
3835
3836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3838 if (SWIG_arg_fail(1)) SWIG_fail;
3839 {
3840 PyThreadState* __tstate = wxPyBeginAllowThreads();
3841 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3842
3843 wxPyEndAllowThreads(__tstate);
3844 if (PyErr_Occurred()) SWIG_fail;
3845 }
3846 {
3847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3848 }
3849 return resultobj;
3850 fail:
3851 return NULL;
3852 }
3853
3854
3855 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3856 PyObject *resultobj;
3857 wxSize *arg1 = (wxSize *) 0 ;
3858 wxSize *arg2 = 0 ;
3859 wxSize temp2 ;
3860 PyObject * obj0 = 0 ;
3861 PyObject * obj1 = 0 ;
3862 char *kwnames[] = {
3863 (char *) "self",(char *) "size", NULL
3864 };
3865
3866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3868 if (SWIG_arg_fail(1)) SWIG_fail;
3869 {
3870 arg2 = &temp2;
3871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3872 }
3873 {
3874 PyThreadState* __tstate = wxPyBeginAllowThreads();
3875 (arg1)->SetDefaults((wxSize const &)*arg2);
3876
3877 wxPyEndAllowThreads(__tstate);
3878 if (PyErr_Occurred()) SWIG_fail;
3879 }
3880 Py_INCREF(Py_None); resultobj = Py_None;
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 wxSize *arg1 = (wxSize *) 0 ;
3890 PyObject *result;
3891 PyObject * obj0 = 0 ;
3892 char *kwnames[] = {
3893 (char *) "self", NULL
3894 };
3895
3896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3898 if (SWIG_arg_fail(1)) SWIG_fail;
3899 {
3900 PyThreadState* __tstate = wxPyBeginAllowThreads();
3901 result = (PyObject *)wxSize_Get(arg1);
3902
3903 wxPyEndAllowThreads(__tstate);
3904 if (PyErr_Occurred()) SWIG_fail;
3905 }
3906 resultobj = result;
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3914 PyObject *obj;
3915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3916 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3917 Py_INCREF(obj);
3918 return Py_BuildValue((char *)"");
3919 }
3920 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3921 PyObject *resultobj;
3922 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3923 double arg2 ;
3924 PyObject * obj0 = 0 ;
3925 PyObject * obj1 = 0 ;
3926 char *kwnames[] = {
3927 (char *) "self",(char *) "x", NULL
3928 };
3929
3930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3932 if (SWIG_arg_fail(1)) SWIG_fail;
3933 {
3934 arg2 = (double)(SWIG_As_double(obj1));
3935 if (SWIG_arg_fail(2)) SWIG_fail;
3936 }
3937 if (arg1) (arg1)->x = arg2;
3938
3939 Py_INCREF(Py_None); resultobj = Py_None;
3940 return resultobj;
3941 fail:
3942 return NULL;
3943 }
3944
3945
3946 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3947 PyObject *resultobj;
3948 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3949 double result;
3950 PyObject * obj0 = 0 ;
3951 char *kwnames[] = {
3952 (char *) "self", NULL
3953 };
3954
3955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3957 if (SWIG_arg_fail(1)) SWIG_fail;
3958 result = (double) ((arg1)->x);
3959
3960 {
3961 resultobj = SWIG_From_double((double)(result));
3962 }
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj;
3971 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3972 double arg2 ;
3973 PyObject * obj0 = 0 ;
3974 PyObject * obj1 = 0 ;
3975 char *kwnames[] = {
3976 (char *) "self",(char *) "y", NULL
3977 };
3978
3979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3981 if (SWIG_arg_fail(1)) SWIG_fail;
3982 {
3983 arg2 = (double)(SWIG_As_double(obj1));
3984 if (SWIG_arg_fail(2)) SWIG_fail;
3985 }
3986 if (arg1) (arg1)->y = arg2;
3987
3988 Py_INCREF(Py_None); resultobj = Py_None;
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3998 double result;
3999 PyObject * obj0 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "self", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4006 if (SWIG_arg_fail(1)) SWIG_fail;
4007 result = (double) ((arg1)->y);
4008
4009 {
4010 resultobj = SWIG_From_double((double)(result));
4011 }
4012 return resultobj;
4013 fail:
4014 return NULL;
4015 }
4016
4017
4018 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4019 PyObject *resultobj;
4020 double arg1 = (double) 0.0 ;
4021 double arg2 = (double) 0.0 ;
4022 wxRealPoint *result;
4023 PyObject * obj0 = 0 ;
4024 PyObject * obj1 = 0 ;
4025 char *kwnames[] = {
4026 (char *) "x",(char *) "y", NULL
4027 };
4028
4029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4030 if (obj0) {
4031 {
4032 arg1 = (double)(SWIG_As_double(obj0));
4033 if (SWIG_arg_fail(1)) SWIG_fail;
4034 }
4035 }
4036 if (obj1) {
4037 {
4038 arg2 = (double)(SWIG_As_double(obj1));
4039 if (SWIG_arg_fail(2)) SWIG_fail;
4040 }
4041 }
4042 {
4043 PyThreadState* __tstate = wxPyBeginAllowThreads();
4044 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4045
4046 wxPyEndAllowThreads(__tstate);
4047 if (PyErr_Occurred()) SWIG_fail;
4048 }
4049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4050 return resultobj;
4051 fail:
4052 return NULL;
4053 }
4054
4055
4056 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4057 PyObject *resultobj;
4058 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4059 PyObject * obj0 = 0 ;
4060 char *kwnames[] = {
4061 (char *) "self", NULL
4062 };
4063
4064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4066 if (SWIG_arg_fail(1)) SWIG_fail;
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 delete arg1;
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 Py_INCREF(Py_None); resultobj = Py_None;
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4084 wxRealPoint *arg2 = 0 ;
4085 bool result;
4086 wxRealPoint temp2 ;
4087 PyObject * obj0 = 0 ;
4088 PyObject * obj1 = 0 ;
4089 char *kwnames[] = {
4090 (char *) "self",(char *) "pt", NULL
4091 };
4092
4093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4095 if (SWIG_arg_fail(1)) SWIG_fail;
4096 {
4097 arg2 = &temp2;
4098 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4099 }
4100 {
4101 PyThreadState* __tstate = wxPyBeginAllowThreads();
4102 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4103
4104 wxPyEndAllowThreads(__tstate);
4105 if (PyErr_Occurred()) SWIG_fail;
4106 }
4107 {
4108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4109 }
4110 return resultobj;
4111 fail:
4112 return NULL;
4113 }
4114
4115
4116 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4117 PyObject *resultobj;
4118 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4119 wxRealPoint *arg2 = 0 ;
4120 bool result;
4121 wxRealPoint temp2 ;
4122 PyObject * obj0 = 0 ;
4123 PyObject * obj1 = 0 ;
4124 char *kwnames[] = {
4125 (char *) "self",(char *) "pt", NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4130 if (SWIG_arg_fail(1)) SWIG_fail;
4131 {
4132 arg2 = &temp2;
4133 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4134 }
4135 {
4136 PyThreadState* __tstate = wxPyBeginAllowThreads();
4137 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4138
4139 wxPyEndAllowThreads(__tstate);
4140 if (PyErr_Occurred()) SWIG_fail;
4141 }
4142 {
4143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4144 }
4145 return resultobj;
4146 fail:
4147 return NULL;
4148 }
4149
4150
4151 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj;
4153 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4154 wxRealPoint *arg2 = 0 ;
4155 wxRealPoint result;
4156 wxRealPoint temp2 ;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 char *kwnames[] = {
4160 (char *) "self",(char *) "pt", NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4165 if (SWIG_arg_fail(1)) SWIG_fail;
4166 {
4167 arg2 = &temp2;
4168 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4169 }
4170 {
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 {
4178 wxRealPoint * resultptr;
4179 resultptr = new wxRealPoint((wxRealPoint &)(result));
4180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4181 }
4182 return resultobj;
4183 fail:
4184 return NULL;
4185 }
4186
4187
4188 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4189 PyObject *resultobj;
4190 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4191 wxRealPoint *arg2 = 0 ;
4192 wxRealPoint result;
4193 wxRealPoint temp2 ;
4194 PyObject * obj0 = 0 ;
4195 PyObject * obj1 = 0 ;
4196 char *kwnames[] = {
4197 (char *) "self",(char *) "pt", NULL
4198 };
4199
4200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4202 if (SWIG_arg_fail(1)) SWIG_fail;
4203 {
4204 arg2 = &temp2;
4205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4206 }
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 wxRealPoint * resultptr;
4216 resultptr = new wxRealPoint((wxRealPoint &)(result));
4217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4228 double arg2 ;
4229 double arg3 ;
4230 PyObject * obj0 = 0 ;
4231 PyObject * obj1 = 0 ;
4232 PyObject * obj2 = 0 ;
4233 char *kwnames[] = {
4234 (char *) "self",(char *) "x",(char *) "y", NULL
4235 };
4236
4237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4239 if (SWIG_arg_fail(1)) SWIG_fail;
4240 {
4241 arg2 = (double)(SWIG_As_double(obj1));
4242 if (SWIG_arg_fail(2)) SWIG_fail;
4243 }
4244 {
4245 arg3 = (double)(SWIG_As_double(obj2));
4246 if (SWIG_arg_fail(3)) SWIG_fail;
4247 }
4248 {
4249 PyThreadState* __tstate = wxPyBeginAllowThreads();
4250 wxRealPoint_Set(arg1,arg2,arg3);
4251
4252 wxPyEndAllowThreads(__tstate);
4253 if (PyErr_Occurred()) SWIG_fail;
4254 }
4255 Py_INCREF(Py_None); resultobj = Py_None;
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4265 PyObject *result;
4266 PyObject * obj0 = 0 ;
4267 char *kwnames[] = {
4268 (char *) "self", NULL
4269 };
4270
4271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4273 if (SWIG_arg_fail(1)) SWIG_fail;
4274 {
4275 PyThreadState* __tstate = wxPyBeginAllowThreads();
4276 result = (PyObject *)wxRealPoint_Get(arg1);
4277
4278 wxPyEndAllowThreads(__tstate);
4279 if (PyErr_Occurred()) SWIG_fail;
4280 }
4281 resultobj = result;
4282 return resultobj;
4283 fail:
4284 return NULL;
4285 }
4286
4287
4288 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4289 PyObject *obj;
4290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4291 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4292 Py_INCREF(obj);
4293 return Py_BuildValue((char *)"");
4294 }
4295 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4296 PyObject *resultobj;
4297 wxPoint *arg1 = (wxPoint *) 0 ;
4298 int arg2 ;
4299 PyObject * obj0 = 0 ;
4300 PyObject * obj1 = 0 ;
4301 char *kwnames[] = {
4302 (char *) "self",(char *) "x", NULL
4303 };
4304
4305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4307 if (SWIG_arg_fail(1)) SWIG_fail;
4308 {
4309 arg2 = (int)(SWIG_As_int(obj1));
4310 if (SWIG_arg_fail(2)) SWIG_fail;
4311 }
4312 if (arg1) (arg1)->x = arg2;
4313
4314 Py_INCREF(Py_None); resultobj = Py_None;
4315 return resultobj;
4316 fail:
4317 return NULL;
4318 }
4319
4320
4321 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4322 PyObject *resultobj;
4323 wxPoint *arg1 = (wxPoint *) 0 ;
4324 int result;
4325 PyObject * obj0 = 0 ;
4326 char *kwnames[] = {
4327 (char *) "self", NULL
4328 };
4329
4330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4332 if (SWIG_arg_fail(1)) SWIG_fail;
4333 result = (int) ((arg1)->x);
4334
4335 {
4336 resultobj = SWIG_From_int((int)(result));
4337 }
4338 return resultobj;
4339 fail:
4340 return NULL;
4341 }
4342
4343
4344 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4345 PyObject *resultobj;
4346 wxPoint *arg1 = (wxPoint *) 0 ;
4347 int arg2 ;
4348 PyObject * obj0 = 0 ;
4349 PyObject * obj1 = 0 ;
4350 char *kwnames[] = {
4351 (char *) "self",(char *) "y", NULL
4352 };
4353
4354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4356 if (SWIG_arg_fail(1)) SWIG_fail;
4357 {
4358 arg2 = (int)(SWIG_As_int(obj1));
4359 if (SWIG_arg_fail(2)) SWIG_fail;
4360 }
4361 if (arg1) (arg1)->y = arg2;
4362
4363 Py_INCREF(Py_None); resultobj = Py_None;
4364 return resultobj;
4365 fail:
4366 return NULL;
4367 }
4368
4369
4370 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj;
4372 wxPoint *arg1 = (wxPoint *) 0 ;
4373 int result;
4374 PyObject * obj0 = 0 ;
4375 char *kwnames[] = {
4376 (char *) "self", NULL
4377 };
4378
4379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4381 if (SWIG_arg_fail(1)) SWIG_fail;
4382 result = (int) ((arg1)->y);
4383
4384 {
4385 resultobj = SWIG_From_int((int)(result));
4386 }
4387 return resultobj;
4388 fail:
4389 return NULL;
4390 }
4391
4392
4393 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4394 PyObject *resultobj;
4395 int arg1 = (int) 0 ;
4396 int arg2 = (int) 0 ;
4397 wxPoint *result;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 char *kwnames[] = {
4401 (char *) "x",(char *) "y", NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4405 if (obj0) {
4406 {
4407 arg1 = (int)(SWIG_As_int(obj0));
4408 if (SWIG_arg_fail(1)) SWIG_fail;
4409 }
4410 }
4411 if (obj1) {
4412 {
4413 arg2 = (int)(SWIG_As_int(obj1));
4414 if (SWIG_arg_fail(2)) SWIG_fail;
4415 }
4416 }
4417 {
4418 PyThreadState* __tstate = wxPyBeginAllowThreads();
4419 result = (wxPoint *)new wxPoint(arg1,arg2);
4420
4421 wxPyEndAllowThreads(__tstate);
4422 if (PyErr_Occurred()) SWIG_fail;
4423 }
4424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4432 PyObject *resultobj;
4433 wxPoint *arg1 = (wxPoint *) 0 ;
4434 PyObject * obj0 = 0 ;
4435 char *kwnames[] = {
4436 (char *) "self", NULL
4437 };
4438
4439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4441 if (SWIG_arg_fail(1)) SWIG_fail;
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 delete arg1;
4445
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 Py_INCREF(Py_None); resultobj = Py_None;
4450 return resultobj;
4451 fail:
4452 return NULL;
4453 }
4454
4455
4456 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj;
4458 wxPoint *arg1 = (wxPoint *) 0 ;
4459 wxPoint *arg2 = 0 ;
4460 bool result;
4461 wxPoint temp2 ;
4462 PyObject * obj0 = 0 ;
4463 PyObject * obj1 = 0 ;
4464 char *kwnames[] = {
4465 (char *) "self",(char *) "pt", NULL
4466 };
4467
4468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4470 if (SWIG_arg_fail(1)) SWIG_fail;
4471 {
4472 arg2 = &temp2;
4473 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4474 }
4475 {
4476 PyThreadState* __tstate = wxPyBeginAllowThreads();
4477 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4478
4479 wxPyEndAllowThreads(__tstate);
4480 if (PyErr_Occurred()) SWIG_fail;
4481 }
4482 {
4483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4492 PyObject *resultobj;
4493 wxPoint *arg1 = (wxPoint *) 0 ;
4494 wxPoint *arg2 = 0 ;
4495 bool result;
4496 wxPoint temp2 ;
4497 PyObject * obj0 = 0 ;
4498 PyObject * obj1 = 0 ;
4499 char *kwnames[] = {
4500 (char *) "self",(char *) "pt", NULL
4501 };
4502
4503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4505 if (SWIG_arg_fail(1)) SWIG_fail;
4506 {
4507 arg2 = &temp2;
4508 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4509 }
4510 {
4511 PyThreadState* __tstate = wxPyBeginAllowThreads();
4512 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4513
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 {
4518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4519 }
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4527 PyObject *resultobj;
4528 wxPoint *arg1 = (wxPoint *) 0 ;
4529 wxPoint *arg2 = 0 ;
4530 wxPoint result;
4531 wxPoint temp2 ;
4532 PyObject * obj0 = 0 ;
4533 PyObject * obj1 = 0 ;
4534 char *kwnames[] = {
4535 (char *) "self",(char *) "pt", NULL
4536 };
4537
4538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4540 if (SWIG_arg_fail(1)) SWIG_fail;
4541 {
4542 arg2 = &temp2;
4543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4544 }
4545 {
4546 PyThreadState* __tstate = wxPyBeginAllowThreads();
4547 result = (arg1)->operator +((wxPoint const &)*arg2);
4548
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 wxPoint * resultptr;
4554 resultptr = new wxPoint((wxPoint &)(result));
4555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4556 }
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4564 PyObject *resultobj;
4565 wxPoint *arg1 = (wxPoint *) 0 ;
4566 wxPoint *arg2 = 0 ;
4567 wxPoint result;
4568 wxPoint temp2 ;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char *kwnames[] = {
4572 (char *) "self",(char *) "pt", NULL
4573 };
4574
4575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4577 if (SWIG_arg_fail(1)) SWIG_fail;
4578 {
4579 arg2 = &temp2;
4580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (arg1)->operator -((wxPoint const &)*arg2);
4585
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 {
4590 wxPoint * resultptr;
4591 resultptr = new wxPoint((wxPoint &)(result));
4592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4593 }
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4601 PyObject *resultobj;
4602 wxPoint *arg1 = (wxPoint *) 0 ;
4603 wxPoint *arg2 = 0 ;
4604 wxPoint *result;
4605 wxPoint temp2 ;
4606 PyObject * obj0 = 0 ;
4607 PyObject * obj1 = 0 ;
4608 char *kwnames[] = {
4609 (char *) "self",(char *) "pt", NULL
4610 };
4611
4612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4614 if (SWIG_arg_fail(1)) SWIG_fail;
4615 {
4616 arg2 = &temp2;
4617 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4618 }
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 {
4622 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4623 result = (wxPoint *) &_result_ref;
4624 }
4625
4626 wxPyEndAllowThreads(__tstate);
4627 if (PyErr_Occurred()) SWIG_fail;
4628 }
4629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4637 PyObject *resultobj;
4638 wxPoint *arg1 = (wxPoint *) 0 ;
4639 wxPoint *arg2 = 0 ;
4640 wxPoint *result;
4641 wxPoint temp2 ;
4642 PyObject * obj0 = 0 ;
4643 PyObject * obj1 = 0 ;
4644 char *kwnames[] = {
4645 (char *) "self",(char *) "pt", NULL
4646 };
4647
4648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4650 if (SWIG_arg_fail(1)) SWIG_fail;
4651 {
4652 arg2 = &temp2;
4653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4654 }
4655 {
4656 PyThreadState* __tstate = wxPyBeginAllowThreads();
4657 {
4658 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4659 result = (wxPoint *) &_result_ref;
4660 }
4661
4662 wxPyEndAllowThreads(__tstate);
4663 if (PyErr_Occurred()) SWIG_fail;
4664 }
4665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4673 PyObject *resultobj;
4674 wxPoint *arg1 = (wxPoint *) 0 ;
4675 long arg2 ;
4676 long arg3 ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 PyObject * obj2 = 0 ;
4680 char *kwnames[] = {
4681 (char *) "self",(char *) "x",(char *) "y", NULL
4682 };
4683
4684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4686 if (SWIG_arg_fail(1)) SWIG_fail;
4687 {
4688 arg2 = (long)(SWIG_As_long(obj1));
4689 if (SWIG_arg_fail(2)) SWIG_fail;
4690 }
4691 {
4692 arg3 = (long)(SWIG_As_long(obj2));
4693 if (SWIG_arg_fail(3)) SWIG_fail;
4694 }
4695 {
4696 PyThreadState* __tstate = wxPyBeginAllowThreads();
4697 wxPoint_Set(arg1,arg2,arg3);
4698
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 Py_INCREF(Py_None); resultobj = Py_None;
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj;
4711 wxPoint *arg1 = (wxPoint *) 0 ;
4712 PyObject *result;
4713 PyObject * obj0 = 0 ;
4714 char *kwnames[] = {
4715 (char *) "self", NULL
4716 };
4717
4718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4720 if (SWIG_arg_fail(1)) SWIG_fail;
4721 {
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = (PyObject *)wxPoint_Get(arg1);
4724
4725 wxPyEndAllowThreads(__tstate);
4726 if (PyErr_Occurred()) SWIG_fail;
4727 }
4728 resultobj = result;
4729 return resultobj;
4730 fail:
4731 return NULL;
4732 }
4733
4734
4735 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4736 PyObject *obj;
4737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4738 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4739 Py_INCREF(obj);
4740 return Py_BuildValue((char *)"");
4741 }
4742 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj;
4744 int arg1 = (int) 0 ;
4745 int arg2 = (int) 0 ;
4746 int arg3 = (int) 0 ;
4747 int arg4 = (int) 0 ;
4748 wxRect *result;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 PyObject * obj2 = 0 ;
4752 PyObject * obj3 = 0 ;
4753 char *kwnames[] = {
4754 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4755 };
4756
4757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4758 if (obj0) {
4759 {
4760 arg1 = (int)(SWIG_As_int(obj0));
4761 if (SWIG_arg_fail(1)) SWIG_fail;
4762 }
4763 }
4764 if (obj1) {
4765 {
4766 arg2 = (int)(SWIG_As_int(obj1));
4767 if (SWIG_arg_fail(2)) SWIG_fail;
4768 }
4769 }
4770 if (obj2) {
4771 {
4772 arg3 = (int)(SWIG_As_int(obj2));
4773 if (SWIG_arg_fail(3)) SWIG_fail;
4774 }
4775 }
4776 if (obj3) {
4777 {
4778 arg4 = (int)(SWIG_As_int(obj3));
4779 if (SWIG_arg_fail(4)) SWIG_fail;
4780 }
4781 }
4782 {
4783 PyThreadState* __tstate = wxPyBeginAllowThreads();
4784 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4785
4786 wxPyEndAllowThreads(__tstate);
4787 if (PyErr_Occurred()) SWIG_fail;
4788 }
4789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4790 return resultobj;
4791 fail:
4792 return NULL;
4793 }
4794
4795
4796 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4797 PyObject *resultobj;
4798 wxPoint *arg1 = 0 ;
4799 wxPoint *arg2 = 0 ;
4800 wxRect *result;
4801 wxPoint temp1 ;
4802 wxPoint temp2 ;
4803 PyObject * obj0 = 0 ;
4804 PyObject * obj1 = 0 ;
4805 char *kwnames[] = {
4806 (char *) "topLeft",(char *) "bottomRight", NULL
4807 };
4808
4809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4810 {
4811 arg1 = &temp1;
4812 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4813 }
4814 {
4815 arg2 = &temp2;
4816 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4817 }
4818 {
4819 PyThreadState* __tstate = wxPyBeginAllowThreads();
4820 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4821
4822 wxPyEndAllowThreads(__tstate);
4823 if (PyErr_Occurred()) SWIG_fail;
4824 }
4825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4826 return resultobj;
4827 fail:
4828 return NULL;
4829 }
4830
4831
4832 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4833 PyObject *resultobj;
4834 wxPoint *arg1 = 0 ;
4835 wxSize *arg2 = 0 ;
4836 wxRect *result;
4837 wxPoint temp1 ;
4838 wxSize temp2 ;
4839 PyObject * obj0 = 0 ;
4840 PyObject * obj1 = 0 ;
4841 char *kwnames[] = {
4842 (char *) "pos",(char *) "size", NULL
4843 };
4844
4845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4846 {
4847 arg1 = &temp1;
4848 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4849 }
4850 {
4851 arg2 = &temp2;
4852 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4853 }
4854 {
4855 PyThreadState* __tstate = wxPyBeginAllowThreads();
4856 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4857
4858 wxPyEndAllowThreads(__tstate);
4859 if (PyErr_Occurred()) SWIG_fail;
4860 }
4861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4862 return resultobj;
4863 fail:
4864 return NULL;
4865 }
4866
4867
4868 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4869 PyObject *resultobj;
4870 wxSize *arg1 = 0 ;
4871 wxRect *result;
4872 wxSize temp1 ;
4873 PyObject * obj0 = 0 ;
4874 char *kwnames[] = {
4875 (char *) "size", NULL
4876 };
4877
4878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4879 {
4880 arg1 = &temp1;
4881 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4882 }
4883 {
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4886
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj;
4899 wxRect *arg1 = (wxRect *) 0 ;
4900 PyObject * obj0 = 0 ;
4901 char *kwnames[] = {
4902 (char *) "self", NULL
4903 };
4904
4905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4907 if (SWIG_arg_fail(1)) SWIG_fail;
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 delete arg1;
4911
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 Py_INCREF(Py_None); resultobj = Py_None;
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxRect *arg1 = (wxRect *) 0 ;
4925 int result;
4926 PyObject * obj0 = 0 ;
4927 char *kwnames[] = {
4928 (char *) "self", NULL
4929 };
4930
4931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4933 if (SWIG_arg_fail(1)) SWIG_fail;
4934 {
4935 PyThreadState* __tstate = wxPyBeginAllowThreads();
4936 result = (int)((wxRect const *)arg1)->GetX();
4937
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 {
4942 resultobj = SWIG_From_int((int)(result));
4943 }
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4951 PyObject *resultobj;
4952 wxRect *arg1 = (wxRect *) 0 ;
4953 int arg2 ;
4954 PyObject * obj0 = 0 ;
4955 PyObject * obj1 = 0 ;
4956 char *kwnames[] = {
4957 (char *) "self",(char *) "x", NULL
4958 };
4959
4960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4962 if (SWIG_arg_fail(1)) SWIG_fail;
4963 {
4964 arg2 = (int)(SWIG_As_int(obj1));
4965 if (SWIG_arg_fail(2)) SWIG_fail;
4966 }
4967 {
4968 PyThreadState* __tstate = wxPyBeginAllowThreads();
4969 (arg1)->SetX(arg2);
4970
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 Py_INCREF(Py_None); resultobj = Py_None;
4975 return resultobj;
4976 fail:
4977 return NULL;
4978 }
4979
4980
4981 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4982 PyObject *resultobj;
4983 wxRect *arg1 = (wxRect *) 0 ;
4984 int result;
4985 PyObject * obj0 = 0 ;
4986 char *kwnames[] = {
4987 (char *) "self", NULL
4988 };
4989
4990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4992 if (SWIG_arg_fail(1)) SWIG_fail;
4993 {
4994 PyThreadState* __tstate = wxPyBeginAllowThreads();
4995 result = (int)(arg1)->GetY();
4996
4997 wxPyEndAllowThreads(__tstate);
4998 if (PyErr_Occurred()) SWIG_fail;
4999 }
5000 {
5001 resultobj = SWIG_From_int((int)(result));
5002 }
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5010 PyObject *resultobj;
5011 wxRect *arg1 = (wxRect *) 0 ;
5012 int arg2 ;
5013 PyObject * obj0 = 0 ;
5014 PyObject * obj1 = 0 ;
5015 char *kwnames[] = {
5016 (char *) "self",(char *) "y", NULL
5017 };
5018
5019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5021 if (SWIG_arg_fail(1)) SWIG_fail;
5022 {
5023 arg2 = (int)(SWIG_As_int(obj1));
5024 if (SWIG_arg_fail(2)) SWIG_fail;
5025 }
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 (arg1)->SetY(arg2);
5029
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 Py_INCREF(Py_None); resultobj = Py_None;
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5041 PyObject *resultobj;
5042 wxRect *arg1 = (wxRect *) 0 ;
5043 int result;
5044 PyObject * obj0 = 0 ;
5045 char *kwnames[] = {
5046 (char *) "self", NULL
5047 };
5048
5049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5051 if (SWIG_arg_fail(1)) SWIG_fail;
5052 {
5053 PyThreadState* __tstate = wxPyBeginAllowThreads();
5054 result = (int)((wxRect const *)arg1)->GetWidth();
5055
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 {
5060 resultobj = SWIG_From_int((int)(result));
5061 }
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5069 PyObject *resultobj;
5070 wxRect *arg1 = (wxRect *) 0 ;
5071 int arg2 ;
5072 PyObject * obj0 = 0 ;
5073 PyObject * obj1 = 0 ;
5074 char *kwnames[] = {
5075 (char *) "self",(char *) "w", NULL
5076 };
5077
5078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5080 if (SWIG_arg_fail(1)) SWIG_fail;
5081 {
5082 arg2 = (int)(SWIG_As_int(obj1));
5083 if (SWIG_arg_fail(2)) SWIG_fail;
5084 }
5085 {
5086 PyThreadState* __tstate = wxPyBeginAllowThreads();
5087 (arg1)->SetWidth(arg2);
5088
5089 wxPyEndAllowThreads(__tstate);
5090 if (PyErr_Occurred()) SWIG_fail;
5091 }
5092 Py_INCREF(Py_None); resultobj = Py_None;
5093 return resultobj;
5094 fail:
5095 return NULL;
5096 }
5097
5098
5099 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5100 PyObject *resultobj;
5101 wxRect *arg1 = (wxRect *) 0 ;
5102 int result;
5103 PyObject * obj0 = 0 ;
5104 char *kwnames[] = {
5105 (char *) "self", NULL
5106 };
5107
5108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5110 if (SWIG_arg_fail(1)) SWIG_fail;
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (int)((wxRect const *)arg1)->GetHeight();
5114
5115 wxPyEndAllowThreads(__tstate);
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 {
5119 resultobj = SWIG_From_int((int)(result));
5120 }
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj;
5129 wxRect *arg1 = (wxRect *) 0 ;
5130 int arg2 ;
5131 PyObject * obj0 = 0 ;
5132 PyObject * obj1 = 0 ;
5133 char *kwnames[] = {
5134 (char *) "self",(char *) "h", NULL
5135 };
5136
5137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5139 if (SWIG_arg_fail(1)) SWIG_fail;
5140 {
5141 arg2 = (int)(SWIG_As_int(obj1));
5142 if (SWIG_arg_fail(2)) SWIG_fail;
5143 }
5144 {
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 (arg1)->SetHeight(arg2);
5147
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 Py_INCREF(Py_None); resultobj = Py_None;
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5159 PyObject *resultobj;
5160 wxRect *arg1 = (wxRect *) 0 ;
5161 wxPoint result;
5162 PyObject * obj0 = 0 ;
5163 char *kwnames[] = {
5164 (char *) "self", NULL
5165 };
5166
5167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5169 if (SWIG_arg_fail(1)) SWIG_fail;
5170 {
5171 PyThreadState* __tstate = wxPyBeginAllowThreads();
5172 result = ((wxRect const *)arg1)->GetPosition();
5173
5174 wxPyEndAllowThreads(__tstate);
5175 if (PyErr_Occurred()) SWIG_fail;
5176 }
5177 {
5178 wxPoint * resultptr;
5179 resultptr = new wxPoint((wxPoint &)(result));
5180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5181 }
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5189 PyObject *resultobj;
5190 wxRect *arg1 = (wxRect *) 0 ;
5191 wxPoint *arg2 = 0 ;
5192 wxPoint temp2 ;
5193 PyObject * obj0 = 0 ;
5194 PyObject * obj1 = 0 ;
5195 char *kwnames[] = {
5196 (char *) "self",(char *) "p", NULL
5197 };
5198
5199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5201 if (SWIG_arg_fail(1)) SWIG_fail;
5202 {
5203 arg2 = &temp2;
5204 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5205 }
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 (arg1)->SetPosition((wxPoint const &)*arg2);
5209
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 Py_INCREF(Py_None); resultobj = Py_None;
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxRect *arg1 = (wxRect *) 0 ;
5223 wxSize result;
5224 PyObject * obj0 = 0 ;
5225 char *kwnames[] = {
5226 (char *) "self", NULL
5227 };
5228
5229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5231 if (SWIG_arg_fail(1)) SWIG_fail;
5232 {
5233 PyThreadState* __tstate = wxPyBeginAllowThreads();
5234 result = ((wxRect const *)arg1)->GetSize();
5235
5236 wxPyEndAllowThreads(__tstate);
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 {
5240 wxSize * resultptr;
5241 resultptr = new wxSize((wxSize &)(result));
5242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5243 }
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj;
5252 wxRect *arg1 = (wxRect *) 0 ;
5253 wxSize *arg2 = 0 ;
5254 wxSize temp2 ;
5255 PyObject * obj0 = 0 ;
5256 PyObject * obj1 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "self",(char *) "s", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5263 if (SWIG_arg_fail(1)) SWIG_fail;
5264 {
5265 arg2 = &temp2;
5266 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5267 }
5268 {
5269 PyThreadState* __tstate = wxPyBeginAllowThreads();
5270 (arg1)->SetSize((wxSize const &)*arg2);
5271
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 Py_INCREF(Py_None); resultobj = Py_None;
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxRect *arg1 = (wxRect *) 0 ;
5285 wxPoint result;
5286 PyObject * obj0 = 0 ;
5287 char *kwnames[] = {
5288 (char *) "self", NULL
5289 };
5290
5291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5293 if (SWIG_arg_fail(1)) SWIG_fail;
5294 {
5295 PyThreadState* __tstate = wxPyBeginAllowThreads();
5296 result = ((wxRect const *)arg1)->GetTopLeft();
5297
5298 wxPyEndAllowThreads(__tstate);
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 {
5302 wxPoint * resultptr;
5303 resultptr = new wxPoint((wxPoint &)(result));
5304 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5305 }
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5313 PyObject *resultobj;
5314 wxRect *arg1 = (wxRect *) 0 ;
5315 wxPoint *arg2 = 0 ;
5316 wxPoint temp2 ;
5317 PyObject * obj0 = 0 ;
5318 PyObject * obj1 = 0 ;
5319 char *kwnames[] = {
5320 (char *) "self",(char *) "p", NULL
5321 };
5322
5323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5325 if (SWIG_arg_fail(1)) SWIG_fail;
5326 {
5327 arg2 = &temp2;
5328 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5329 }
5330 {
5331 PyThreadState* __tstate = wxPyBeginAllowThreads();
5332 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5333
5334 wxPyEndAllowThreads(__tstate);
5335 if (PyErr_Occurred()) SWIG_fail;
5336 }
5337 Py_INCREF(Py_None); resultobj = Py_None;
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5345 PyObject *resultobj;
5346 wxRect *arg1 = (wxRect *) 0 ;
5347 wxPoint result;
5348 PyObject * obj0 = 0 ;
5349 char *kwnames[] = {
5350 (char *) "self", NULL
5351 };
5352
5353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5355 if (SWIG_arg_fail(1)) SWIG_fail;
5356 {
5357 PyThreadState* __tstate = wxPyBeginAllowThreads();
5358 result = ((wxRect const *)arg1)->GetBottomRight();
5359
5360 wxPyEndAllowThreads(__tstate);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 wxPoint * resultptr;
5365 resultptr = new wxPoint((wxPoint &)(result));
5366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5367 }
5368 return resultobj;
5369 fail:
5370 return NULL;
5371 }
5372
5373
5374 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj;
5376 wxRect *arg1 = (wxRect *) 0 ;
5377 wxPoint *arg2 = 0 ;
5378 wxPoint temp2 ;
5379 PyObject * obj0 = 0 ;
5380 PyObject * obj1 = 0 ;
5381 char *kwnames[] = {
5382 (char *) "self",(char *) "p", NULL
5383 };
5384
5385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5387 if (SWIG_arg_fail(1)) SWIG_fail;
5388 {
5389 arg2 = &temp2;
5390 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5391 }
5392 {
5393 PyThreadState* __tstate = wxPyBeginAllowThreads();
5394 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5395
5396 wxPyEndAllowThreads(__tstate);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 Py_INCREF(Py_None); resultobj = Py_None;
5400 return resultobj;
5401 fail:
5402 return NULL;
5403 }
5404
5405
5406 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj;
5408 wxRect *arg1 = (wxRect *) 0 ;
5409 int result;
5410 PyObject * obj0 = 0 ;
5411 char *kwnames[] = {
5412 (char *) "self", NULL
5413 };
5414
5415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5417 if (SWIG_arg_fail(1)) SWIG_fail;
5418 {
5419 PyThreadState* __tstate = wxPyBeginAllowThreads();
5420 result = (int)((wxRect const *)arg1)->GetLeft();
5421
5422 wxPyEndAllowThreads(__tstate);
5423 if (PyErr_Occurred()) SWIG_fail;
5424 }
5425 {
5426 resultobj = SWIG_From_int((int)(result));
5427 }
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5435 PyObject *resultobj;
5436 wxRect *arg1 = (wxRect *) 0 ;
5437 int result;
5438 PyObject * obj0 = 0 ;
5439 char *kwnames[] = {
5440 (char *) "self", NULL
5441 };
5442
5443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5445 if (SWIG_arg_fail(1)) SWIG_fail;
5446 {
5447 PyThreadState* __tstate = wxPyBeginAllowThreads();
5448 result = (int)((wxRect const *)arg1)->GetTop();
5449
5450 wxPyEndAllowThreads(__tstate);
5451 if (PyErr_Occurred()) SWIG_fail;
5452 }
5453 {
5454 resultobj = SWIG_From_int((int)(result));
5455 }
5456 return resultobj;
5457 fail:
5458 return NULL;
5459 }
5460
5461
5462 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj;
5464 wxRect *arg1 = (wxRect *) 0 ;
5465 int result;
5466 PyObject * obj0 = 0 ;
5467 char *kwnames[] = {
5468 (char *) "self", NULL
5469 };
5470
5471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5473 if (SWIG_arg_fail(1)) SWIG_fail;
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 result = (int)((wxRect const *)arg1)->GetBottom();
5477
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 {
5482 resultobj = SWIG_From_int((int)(result));
5483 }
5484 return resultobj;
5485 fail:
5486 return NULL;
5487 }
5488
5489
5490 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5491 PyObject *resultobj;
5492 wxRect *arg1 = (wxRect *) 0 ;
5493 int result;
5494 PyObject * obj0 = 0 ;
5495 char *kwnames[] = {
5496 (char *) "self", NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5501 if (SWIG_arg_fail(1)) SWIG_fail;
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = (int)((wxRect const *)arg1)->GetRight();
5505
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 {
5510 resultobj = SWIG_From_int((int)(result));
5511 }
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj;
5520 wxRect *arg1 = (wxRect *) 0 ;
5521 int arg2 ;
5522 PyObject * obj0 = 0 ;
5523 PyObject * obj1 = 0 ;
5524 char *kwnames[] = {
5525 (char *) "self",(char *) "left", NULL
5526 };
5527
5528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5530 if (SWIG_arg_fail(1)) SWIG_fail;
5531 {
5532 arg2 = (int)(SWIG_As_int(obj1));
5533 if (SWIG_arg_fail(2)) SWIG_fail;
5534 }
5535 {
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 (arg1)->SetLeft(arg2);
5538
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 Py_INCREF(Py_None); resultobj = Py_None;
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5550 PyObject *resultobj;
5551 wxRect *arg1 = (wxRect *) 0 ;
5552 int arg2 ;
5553 PyObject * obj0 = 0 ;
5554 PyObject * obj1 = 0 ;
5555 char *kwnames[] = {
5556 (char *) "self",(char *) "right", NULL
5557 };
5558
5559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5561 if (SWIG_arg_fail(1)) SWIG_fail;
5562 {
5563 arg2 = (int)(SWIG_As_int(obj1));
5564 if (SWIG_arg_fail(2)) SWIG_fail;
5565 }
5566 {
5567 PyThreadState* __tstate = wxPyBeginAllowThreads();
5568 (arg1)->SetRight(arg2);
5569
5570 wxPyEndAllowThreads(__tstate);
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 Py_INCREF(Py_None); resultobj = Py_None;
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5581 PyObject *resultobj;
5582 wxRect *arg1 = (wxRect *) 0 ;
5583 int arg2 ;
5584 PyObject * obj0 = 0 ;
5585 PyObject * obj1 = 0 ;
5586 char *kwnames[] = {
5587 (char *) "self",(char *) "top", NULL
5588 };
5589
5590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5592 if (SWIG_arg_fail(1)) SWIG_fail;
5593 {
5594 arg2 = (int)(SWIG_As_int(obj1));
5595 if (SWIG_arg_fail(2)) SWIG_fail;
5596 }
5597 {
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 (arg1)->SetTop(arg2);
5600
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 Py_INCREF(Py_None); resultobj = Py_None;
5605 return resultobj;
5606 fail:
5607 return NULL;
5608 }
5609
5610
5611 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5612 PyObject *resultobj;
5613 wxRect *arg1 = (wxRect *) 0 ;
5614 int arg2 ;
5615 PyObject * obj0 = 0 ;
5616 PyObject * obj1 = 0 ;
5617 char *kwnames[] = {
5618 (char *) "self",(char *) "bottom", NULL
5619 };
5620
5621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5623 if (SWIG_arg_fail(1)) SWIG_fail;
5624 {
5625 arg2 = (int)(SWIG_As_int(obj1));
5626 if (SWIG_arg_fail(2)) SWIG_fail;
5627 }
5628 {
5629 PyThreadState* __tstate = wxPyBeginAllowThreads();
5630 (arg1)->SetBottom(arg2);
5631
5632 wxPyEndAllowThreads(__tstate);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 Py_INCREF(Py_None); resultobj = Py_None;
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj;
5644 wxRect *arg1 = (wxRect *) 0 ;
5645 int arg2 ;
5646 int arg3 ;
5647 wxRect *result;
5648 PyObject * obj0 = 0 ;
5649 PyObject * obj1 = 0 ;
5650 PyObject * obj2 = 0 ;
5651 char *kwnames[] = {
5652 (char *) "self",(char *) "dx",(char *) "dy", NULL
5653 };
5654
5655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5657 if (SWIG_arg_fail(1)) SWIG_fail;
5658 {
5659 arg2 = (int)(SWIG_As_int(obj1));
5660 if (SWIG_arg_fail(2)) SWIG_fail;
5661 }
5662 {
5663 arg3 = (int)(SWIG_As_int(obj2));
5664 if (SWIG_arg_fail(3)) SWIG_fail;
5665 }
5666 {
5667 PyThreadState* __tstate = wxPyBeginAllowThreads();
5668 {
5669 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5670 result = (wxRect *) &_result_ref;
5671 }
5672
5673 wxPyEndAllowThreads(__tstate);
5674 if (PyErr_Occurred()) SWIG_fail;
5675 }
5676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5677 return resultobj;
5678 fail:
5679 return NULL;
5680 }
5681
5682
5683 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5684 PyObject *resultobj;
5685 wxRect *arg1 = (wxRect *) 0 ;
5686 int arg2 ;
5687 int arg3 ;
5688 wxRect *result;
5689 PyObject * obj0 = 0 ;
5690 PyObject * obj1 = 0 ;
5691 PyObject * obj2 = 0 ;
5692 char *kwnames[] = {
5693 (char *) "self",(char *) "dx",(char *) "dy", NULL
5694 };
5695
5696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5698 if (SWIG_arg_fail(1)) SWIG_fail;
5699 {
5700 arg2 = (int)(SWIG_As_int(obj1));
5701 if (SWIG_arg_fail(2)) SWIG_fail;
5702 }
5703 {
5704 arg3 = (int)(SWIG_As_int(obj2));
5705 if (SWIG_arg_fail(3)) SWIG_fail;
5706 }
5707 {
5708 PyThreadState* __tstate = wxPyBeginAllowThreads();
5709 {
5710 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5711 result = (wxRect *) &_result_ref;
5712 }
5713
5714 wxPyEndAllowThreads(__tstate);
5715 if (PyErr_Occurred()) SWIG_fail;
5716 }
5717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5718 return resultobj;
5719 fail:
5720 return NULL;
5721 }
5722
5723
5724 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5725 PyObject *resultobj;
5726 wxRect *arg1 = (wxRect *) 0 ;
5727 int arg2 ;
5728 int arg3 ;
5729 PyObject * obj0 = 0 ;
5730 PyObject * obj1 = 0 ;
5731 PyObject * obj2 = 0 ;
5732 char *kwnames[] = {
5733 (char *) "self",(char *) "dx",(char *) "dy", NULL
5734 };
5735
5736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5738 if (SWIG_arg_fail(1)) SWIG_fail;
5739 {
5740 arg2 = (int)(SWIG_As_int(obj1));
5741 if (SWIG_arg_fail(2)) SWIG_fail;
5742 }
5743 {
5744 arg3 = (int)(SWIG_As_int(obj2));
5745 if (SWIG_arg_fail(3)) SWIG_fail;
5746 }
5747 {
5748 PyThreadState* __tstate = wxPyBeginAllowThreads();
5749 (arg1)->Offset(arg2,arg3);
5750
5751 wxPyEndAllowThreads(__tstate);
5752 if (PyErr_Occurred()) SWIG_fail;
5753 }
5754 Py_INCREF(Py_None); resultobj = Py_None;
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5762 PyObject *resultobj;
5763 wxRect *arg1 = (wxRect *) 0 ;
5764 wxPoint *arg2 = 0 ;
5765 wxPoint temp2 ;
5766 PyObject * obj0 = 0 ;
5767 PyObject * obj1 = 0 ;
5768 char *kwnames[] = {
5769 (char *) "self",(char *) "pt", NULL
5770 };
5771
5772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5774 if (SWIG_arg_fail(1)) SWIG_fail;
5775 {
5776 arg2 = &temp2;
5777 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5778 }
5779 {
5780 PyThreadState* __tstate = wxPyBeginAllowThreads();
5781 (arg1)->Offset((wxPoint const &)*arg2);
5782
5783 wxPyEndAllowThreads(__tstate);
5784 if (PyErr_Occurred()) SWIG_fail;
5785 }
5786 Py_INCREF(Py_None); resultobj = Py_None;
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5794 PyObject *resultobj;
5795 wxRect *arg1 = (wxRect *) 0 ;
5796 wxRect *arg2 = 0 ;
5797 wxRect result;
5798 wxRect temp2 ;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 char *kwnames[] = {
5802 (char *) "self",(char *) "rect", NULL
5803 };
5804
5805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5807 if (SWIG_arg_fail(1)) SWIG_fail;
5808 {
5809 arg2 = &temp2;
5810 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5811 }
5812 {
5813 PyThreadState* __tstate = wxPyBeginAllowThreads();
5814 result = (arg1)->Intersect((wxRect const &)*arg2);
5815
5816 wxPyEndAllowThreads(__tstate);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 {
5820 wxRect * resultptr;
5821 resultptr = new wxRect((wxRect &)(result));
5822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5823 }
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj;
5832 wxRect *arg1 = (wxRect *) 0 ;
5833 wxRect *arg2 = 0 ;
5834 wxRect result;
5835 wxRect temp2 ;
5836 PyObject * obj0 = 0 ;
5837 PyObject * obj1 = 0 ;
5838 char *kwnames[] = {
5839 (char *) "self",(char *) "rect", NULL
5840 };
5841
5842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5844 if (SWIG_arg_fail(1)) SWIG_fail;
5845 {
5846 arg2 = &temp2;
5847 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5848 }
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 result = (arg1)->Union((wxRect const &)*arg2);
5852
5853 wxPyEndAllowThreads(__tstate);
5854 if (PyErr_Occurred()) SWIG_fail;
5855 }
5856 {
5857 wxRect * resultptr;
5858 resultptr = new wxRect((wxRect &)(result));
5859 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5860 }
5861 return resultobj;
5862 fail:
5863 return NULL;
5864 }
5865
5866
5867 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5868 PyObject *resultobj;
5869 wxRect *arg1 = (wxRect *) 0 ;
5870 wxRect *arg2 = 0 ;
5871 wxRect result;
5872 wxRect temp2 ;
5873 PyObject * obj0 = 0 ;
5874 PyObject * obj1 = 0 ;
5875 char *kwnames[] = {
5876 (char *) "self",(char *) "rect", NULL
5877 };
5878
5879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5881 if (SWIG_arg_fail(1)) SWIG_fail;
5882 {
5883 arg2 = &temp2;
5884 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5885 }
5886 {
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5889
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 {
5894 wxRect * resultptr;
5895 resultptr = new wxRect((wxRect &)(result));
5896 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5897 }
5898 return resultobj;
5899 fail:
5900 return NULL;
5901 }
5902
5903
5904 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5905 PyObject *resultobj;
5906 wxRect *arg1 = (wxRect *) 0 ;
5907 wxRect *arg2 = 0 ;
5908 wxRect *result;
5909 wxRect temp2 ;
5910 PyObject * obj0 = 0 ;
5911 PyObject * obj1 = 0 ;
5912 char *kwnames[] = {
5913 (char *) "self",(char *) "rect", NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5918 if (SWIG_arg_fail(1)) SWIG_fail;
5919 {
5920 arg2 = &temp2;
5921 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5922 }
5923 {
5924 PyThreadState* __tstate = wxPyBeginAllowThreads();
5925 {
5926 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5927 result = (wxRect *) &_result_ref;
5928 }
5929
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj;
5942 wxRect *arg1 = (wxRect *) 0 ;
5943 wxRect *arg2 = 0 ;
5944 bool result;
5945 wxRect temp2 ;
5946 PyObject * obj0 = 0 ;
5947 PyObject * obj1 = 0 ;
5948 char *kwnames[] = {
5949 (char *) "self",(char *) "rect", NULL
5950 };
5951
5952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5954 if (SWIG_arg_fail(1)) SWIG_fail;
5955 {
5956 arg2 = &temp2;
5957 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5958 }
5959 {
5960 PyThreadState* __tstate = wxPyBeginAllowThreads();
5961 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5962
5963 wxPyEndAllowThreads(__tstate);
5964 if (PyErr_Occurred()) SWIG_fail;
5965 }
5966 {
5967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5968 }
5969 return resultobj;
5970 fail:
5971 return NULL;
5972 }
5973
5974
5975 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5976 PyObject *resultobj;
5977 wxRect *arg1 = (wxRect *) 0 ;
5978 wxRect *arg2 = 0 ;
5979 bool result;
5980 wxRect temp2 ;
5981 PyObject * obj0 = 0 ;
5982 PyObject * obj1 = 0 ;
5983 char *kwnames[] = {
5984 (char *) "self",(char *) "rect", NULL
5985 };
5986
5987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5989 if (SWIG_arg_fail(1)) SWIG_fail;
5990 {
5991 arg2 = &temp2;
5992 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5993 }
5994 {
5995 PyThreadState* __tstate = wxPyBeginAllowThreads();
5996 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5997
5998 wxPyEndAllowThreads(__tstate);
5999 if (PyErr_Occurred()) SWIG_fail;
6000 }
6001 {
6002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6003 }
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj;
6012 wxRect *arg1 = (wxRect *) 0 ;
6013 int arg2 ;
6014 int arg3 ;
6015 bool result;
6016 PyObject * obj0 = 0 ;
6017 PyObject * obj1 = 0 ;
6018 PyObject * obj2 = 0 ;
6019 char *kwnames[] = {
6020 (char *) "self",(char *) "x",(char *) "y", NULL
6021 };
6022
6023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6025 if (SWIG_arg_fail(1)) SWIG_fail;
6026 {
6027 arg2 = (int)(SWIG_As_int(obj1));
6028 if (SWIG_arg_fail(2)) SWIG_fail;
6029 }
6030 {
6031 arg3 = (int)(SWIG_As_int(obj2));
6032 if (SWIG_arg_fail(3)) SWIG_fail;
6033 }
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6037
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 {
6042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6043 }
6044 return resultobj;
6045 fail:
6046 return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj;
6052 wxRect *arg1 = (wxRect *) 0 ;
6053 wxPoint *arg2 = 0 ;
6054 bool result;
6055 wxPoint temp2 ;
6056 PyObject * obj0 = 0 ;
6057 PyObject * obj1 = 0 ;
6058 char *kwnames[] = {
6059 (char *) "self",(char *) "pt", NULL
6060 };
6061
6062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6064 if (SWIG_arg_fail(1)) SWIG_fail;
6065 {
6066 arg2 = &temp2;
6067 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6068 }
6069 {
6070 PyThreadState* __tstate = wxPyBeginAllowThreads();
6071 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6072
6073 wxPyEndAllowThreads(__tstate);
6074 if (PyErr_Occurred()) SWIG_fail;
6075 }
6076 {
6077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6078 }
6079 return resultobj;
6080 fail:
6081 return NULL;
6082 }
6083
6084
6085 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6086 PyObject *resultobj;
6087 wxRect *arg1 = (wxRect *) 0 ;
6088 wxRect *arg2 = 0 ;
6089 bool result;
6090 wxRect temp2 ;
6091 PyObject * obj0 = 0 ;
6092 PyObject * obj1 = 0 ;
6093 char *kwnames[] = {
6094 (char *) "self",(char *) "rect", NULL
6095 };
6096
6097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6099 if (SWIG_arg_fail(1)) SWIG_fail;
6100 {
6101 arg2 = &temp2;
6102 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6103 }
6104 {
6105 PyThreadState* __tstate = wxPyBeginAllowThreads();
6106 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6107
6108 wxPyEndAllowThreads(__tstate);
6109 if (PyErr_Occurred()) SWIG_fail;
6110 }
6111 {
6112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6113 }
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj;
6122 wxRect *arg1 = (wxRect *) 0 ;
6123 int arg2 ;
6124 PyObject * obj0 = 0 ;
6125 PyObject * obj1 = 0 ;
6126 char *kwnames[] = {
6127 (char *) "self",(char *) "x", NULL
6128 };
6129
6130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6132 if (SWIG_arg_fail(1)) SWIG_fail;
6133 {
6134 arg2 = (int)(SWIG_As_int(obj1));
6135 if (SWIG_arg_fail(2)) SWIG_fail;
6136 }
6137 if (arg1) (arg1)->x = arg2;
6138
6139 Py_INCREF(Py_None); resultobj = Py_None;
6140 return resultobj;
6141 fail:
6142 return NULL;
6143 }
6144
6145
6146 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6147 PyObject *resultobj;
6148 wxRect *arg1 = (wxRect *) 0 ;
6149 int result;
6150 PyObject * obj0 = 0 ;
6151 char *kwnames[] = {
6152 (char *) "self", NULL
6153 };
6154
6155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6157 if (SWIG_arg_fail(1)) SWIG_fail;
6158 result = (int) ((arg1)->x);
6159
6160 {
6161 resultobj = SWIG_From_int((int)(result));
6162 }
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj;
6171 wxRect *arg1 = (wxRect *) 0 ;
6172 int arg2 ;
6173 PyObject * obj0 = 0 ;
6174 PyObject * obj1 = 0 ;
6175 char *kwnames[] = {
6176 (char *) "self",(char *) "y", NULL
6177 };
6178
6179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6181 if (SWIG_arg_fail(1)) SWIG_fail;
6182 {
6183 arg2 = (int)(SWIG_As_int(obj1));
6184 if (SWIG_arg_fail(2)) SWIG_fail;
6185 }
6186 if (arg1) (arg1)->y = arg2;
6187
6188 Py_INCREF(Py_None); resultobj = Py_None;
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6196 PyObject *resultobj;
6197 wxRect *arg1 = (wxRect *) 0 ;
6198 int result;
6199 PyObject * obj0 = 0 ;
6200 char *kwnames[] = {
6201 (char *) "self", NULL
6202 };
6203
6204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6206 if (SWIG_arg_fail(1)) SWIG_fail;
6207 result = (int) ((arg1)->y);
6208
6209 {
6210 resultobj = SWIG_From_int((int)(result));
6211 }
6212 return resultobj;
6213 fail:
6214 return NULL;
6215 }
6216
6217
6218 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6219 PyObject *resultobj;
6220 wxRect *arg1 = (wxRect *) 0 ;
6221 int arg2 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 char *kwnames[] = {
6225 (char *) "self",(char *) "width", NULL
6226 };
6227
6228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6230 if (SWIG_arg_fail(1)) SWIG_fail;
6231 {
6232 arg2 = (int)(SWIG_As_int(obj1));
6233 if (SWIG_arg_fail(2)) SWIG_fail;
6234 }
6235 if (arg1) (arg1)->width = arg2;
6236
6237 Py_INCREF(Py_None); resultobj = Py_None;
6238 return resultobj;
6239 fail:
6240 return NULL;
6241 }
6242
6243
6244 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6245 PyObject *resultobj;
6246 wxRect *arg1 = (wxRect *) 0 ;
6247 int result;
6248 PyObject * obj0 = 0 ;
6249 char *kwnames[] = {
6250 (char *) "self", NULL
6251 };
6252
6253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6255 if (SWIG_arg_fail(1)) SWIG_fail;
6256 result = (int) ((arg1)->width);
6257
6258 {
6259 resultobj = SWIG_From_int((int)(result));
6260 }
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int arg2 ;
6271 PyObject * obj0 = 0 ;
6272 PyObject * obj1 = 0 ;
6273 char *kwnames[] = {
6274 (char *) "self",(char *) "height", NULL
6275 };
6276
6277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6279 if (SWIG_arg_fail(1)) SWIG_fail;
6280 {
6281 arg2 = (int)(SWIG_As_int(obj1));
6282 if (SWIG_arg_fail(2)) SWIG_fail;
6283 }
6284 if (arg1) (arg1)->height = arg2;
6285
6286 Py_INCREF(Py_None); resultobj = Py_None;
6287 return resultobj;
6288 fail:
6289 return NULL;
6290 }
6291
6292
6293 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6294 PyObject *resultobj;
6295 wxRect *arg1 = (wxRect *) 0 ;
6296 int result;
6297 PyObject * obj0 = 0 ;
6298 char *kwnames[] = {
6299 (char *) "self", NULL
6300 };
6301
6302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6304 if (SWIG_arg_fail(1)) SWIG_fail;
6305 result = (int) ((arg1)->height);
6306
6307 {
6308 resultobj = SWIG_From_int((int)(result));
6309 }
6310 return resultobj;
6311 fail:
6312 return NULL;
6313 }
6314
6315
6316 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6317 PyObject *resultobj;
6318 wxRect *arg1 = (wxRect *) 0 ;
6319 int arg2 = (int) 0 ;
6320 int arg3 = (int) 0 ;
6321 int arg4 = (int) 0 ;
6322 int arg5 = (int) 0 ;
6323 PyObject * obj0 = 0 ;
6324 PyObject * obj1 = 0 ;
6325 PyObject * obj2 = 0 ;
6326 PyObject * obj3 = 0 ;
6327 PyObject * obj4 = 0 ;
6328 char *kwnames[] = {
6329 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6330 };
6331
6332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6334 if (SWIG_arg_fail(1)) SWIG_fail;
6335 if (obj1) {
6336 {
6337 arg2 = (int)(SWIG_As_int(obj1));
6338 if (SWIG_arg_fail(2)) SWIG_fail;
6339 }
6340 }
6341 if (obj2) {
6342 {
6343 arg3 = (int)(SWIG_As_int(obj2));
6344 if (SWIG_arg_fail(3)) SWIG_fail;
6345 }
6346 }
6347 if (obj3) {
6348 {
6349 arg4 = (int)(SWIG_As_int(obj3));
6350 if (SWIG_arg_fail(4)) SWIG_fail;
6351 }
6352 }
6353 if (obj4) {
6354 {
6355 arg5 = (int)(SWIG_As_int(obj4));
6356 if (SWIG_arg_fail(5)) SWIG_fail;
6357 }
6358 }
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6362
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 Py_INCREF(Py_None); resultobj = Py_None;
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6374 PyObject *resultobj;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 PyObject *result;
6377 PyObject * obj0 = 0 ;
6378 char *kwnames[] = {
6379 (char *) "self", NULL
6380 };
6381
6382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6384 if (SWIG_arg_fail(1)) SWIG_fail;
6385 {
6386 PyThreadState* __tstate = wxPyBeginAllowThreads();
6387 result = (PyObject *)wxRect_Get(arg1);
6388
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = result;
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6400 PyObject *obj;
6401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6402 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6403 Py_INCREF(obj);
6404 return Py_BuildValue((char *)"");
6405 }
6406 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6407 PyObject *resultobj;
6408 wxRect *arg1 = (wxRect *) 0 ;
6409 wxRect *arg2 = (wxRect *) 0 ;
6410 PyObject *result;
6411 PyObject * obj0 = 0 ;
6412 PyObject * obj1 = 0 ;
6413 char *kwnames[] = {
6414 (char *) "r1",(char *) "r2", NULL
6415 };
6416
6417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6419 if (SWIG_arg_fail(1)) SWIG_fail;
6420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6421 if (SWIG_arg_fail(2)) SWIG_fail;
6422 {
6423 if (!wxPyCheckForApp()) SWIG_fail;
6424 PyThreadState* __tstate = wxPyBeginAllowThreads();
6425 result = (PyObject *)wxIntersectRect(arg1,arg2);
6426
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = result;
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6438 PyObject *resultobj;
6439 double arg1 = (double) 0.0 ;
6440 double arg2 = (double) 0.0 ;
6441 wxPoint2D *result;
6442 PyObject * obj0 = 0 ;
6443 PyObject * obj1 = 0 ;
6444 char *kwnames[] = {
6445 (char *) "x",(char *) "y", NULL
6446 };
6447
6448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6449 if (obj0) {
6450 {
6451 arg1 = (double)(SWIG_As_double(obj0));
6452 if (SWIG_arg_fail(1)) SWIG_fail;
6453 }
6454 }
6455 if (obj1) {
6456 {
6457 arg2 = (double)(SWIG_As_double(obj1));
6458 if (SWIG_arg_fail(2)) SWIG_fail;
6459 }
6460 }
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6464
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj;
6477 wxPoint2D *arg1 = 0 ;
6478 wxPoint2D *result;
6479 wxPoint2D temp1 ;
6480 PyObject * obj0 = 0 ;
6481 char *kwnames[] = {
6482 (char *) "pt", NULL
6483 };
6484
6485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6486 {
6487 arg1 = &temp1;
6488 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6489 }
6490 {
6491 PyThreadState* __tstate = wxPyBeginAllowThreads();
6492 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6493
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj;
6506 wxPoint *arg1 = 0 ;
6507 wxPoint2D *result;
6508 wxPoint temp1 ;
6509 PyObject * obj0 = 0 ;
6510 char *kwnames[] = {
6511 (char *) "pt", NULL
6512 };
6513
6514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6515 {
6516 arg1 = &temp1;
6517 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6518 }
6519 {
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6522
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj;
6535 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6536 int *arg2 = (int *) 0 ;
6537 int *arg3 = (int *) 0 ;
6538 int temp2 ;
6539 int res2 = 0 ;
6540 int temp3 ;
6541 int res3 = 0 ;
6542 PyObject * obj0 = 0 ;
6543 char *kwnames[] = {
6544 (char *) "self", NULL
6545 };
6546
6547 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6548 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6551 if (SWIG_arg_fail(1)) SWIG_fail;
6552 {
6553 PyThreadState* __tstate = wxPyBeginAllowThreads();
6554 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6555
6556 wxPyEndAllowThreads(__tstate);
6557 if (PyErr_Occurred()) SWIG_fail;
6558 }
6559 Py_INCREF(Py_None); resultobj = Py_None;
6560 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6561 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6562 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6563 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj;
6572 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6573 int *arg2 = (int *) 0 ;
6574 int *arg3 = (int *) 0 ;
6575 int temp2 ;
6576 int res2 = 0 ;
6577 int temp3 ;
6578 int res3 = 0 ;
6579 PyObject * obj0 = 0 ;
6580 char *kwnames[] = {
6581 (char *) "self", NULL
6582 };
6583
6584 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6585 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6588 if (SWIG_arg_fail(1)) SWIG_fail;
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6592
6593 wxPyEndAllowThreads(__tstate);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 Py_INCREF(Py_None); resultobj = Py_None;
6597 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6598 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6599 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6600 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6608 PyObject *resultobj;
6609 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6610 double result;
6611 PyObject * obj0 = 0 ;
6612 char *kwnames[] = {
6613 (char *) "self", NULL
6614 };
6615
6616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6618 if (SWIG_arg_fail(1)) SWIG_fail;
6619 {
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6622
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 {
6627 resultobj = SWIG_From_double((double)(result));
6628 }
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj;
6637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6638 double result;
6639 PyObject * obj0 = 0 ;
6640 char *kwnames[] = {
6641 (char *) "self", NULL
6642 };
6643
6644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6646 if (SWIG_arg_fail(1)) SWIG_fail;
6647 {
6648 PyThreadState* __tstate = wxPyBeginAllowThreads();
6649 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6650
6651 wxPyEndAllowThreads(__tstate);
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 {
6655 resultobj = SWIG_From_double((double)(result));
6656 }
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6664 PyObject *resultobj;
6665 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6666 double arg2 ;
6667 PyObject * obj0 = 0 ;
6668 PyObject * obj1 = 0 ;
6669 char *kwnames[] = {
6670 (char *) "self",(char *) "length", NULL
6671 };
6672
6673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6675 if (SWIG_arg_fail(1)) SWIG_fail;
6676 {
6677 arg2 = (double)(SWIG_As_double(obj1));
6678 if (SWIG_arg_fail(2)) SWIG_fail;
6679 }
6680 {
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 (arg1)->SetVectorLength(arg2);
6683
6684 wxPyEndAllowThreads(__tstate);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 Py_INCREF(Py_None); resultobj = Py_None;
6688 return resultobj;
6689 fail:
6690 return NULL;
6691 }
6692
6693
6694 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6695 PyObject *resultobj;
6696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6697 double arg2 ;
6698 PyObject * obj0 = 0 ;
6699 PyObject * obj1 = 0 ;
6700 char *kwnames[] = {
6701 (char *) "self",(char *) "degrees", NULL
6702 };
6703
6704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6706 if (SWIG_arg_fail(1)) SWIG_fail;
6707 {
6708 arg2 = (double)(SWIG_As_double(obj1));
6709 if (SWIG_arg_fail(2)) SWIG_fail;
6710 }
6711 {
6712 PyThreadState* __tstate = wxPyBeginAllowThreads();
6713 (arg1)->SetVectorAngle(arg2);
6714
6715 wxPyEndAllowThreads(__tstate);
6716 if (PyErr_Occurred()) SWIG_fail;
6717 }
6718 Py_INCREF(Py_None); resultobj = Py_None;
6719 return resultobj;
6720 fail:
6721 return NULL;
6722 }
6723
6724
6725 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6726 PyObject *resultobj;
6727 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6728 wxPoint2D *arg2 = 0 ;
6729 double result;
6730 wxPoint2D temp2 ;
6731 PyObject * obj0 = 0 ;
6732 PyObject * obj1 = 0 ;
6733 char *kwnames[] = {
6734 (char *) "self",(char *) "pt", NULL
6735 };
6736
6737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6739 if (SWIG_arg_fail(1)) SWIG_fail;
6740 {
6741 arg2 = &temp2;
6742 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6743 }
6744 {
6745 PyThreadState* __tstate = wxPyBeginAllowThreads();
6746 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6747
6748 wxPyEndAllowThreads(__tstate);
6749 if (PyErr_Occurred()) SWIG_fail;
6750 }
6751 {
6752 resultobj = SWIG_From_double((double)(result));
6753 }
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6761 PyObject *resultobj;
6762 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6763 wxPoint2D *arg2 = 0 ;
6764 double result;
6765 wxPoint2D temp2 ;
6766 PyObject * obj0 = 0 ;
6767 PyObject * obj1 = 0 ;
6768 char *kwnames[] = {
6769 (char *) "self",(char *) "pt", NULL
6770 };
6771
6772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6774 if (SWIG_arg_fail(1)) SWIG_fail;
6775 {
6776 arg2 = &temp2;
6777 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6778 }
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6782
6783 wxPyEndAllowThreads(__tstate);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 {
6787 resultobj = SWIG_From_double((double)(result));
6788 }
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6796 PyObject *resultobj;
6797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6798 wxPoint2D *arg2 = 0 ;
6799 double result;
6800 wxPoint2D temp2 ;
6801 PyObject * obj0 = 0 ;
6802 PyObject * obj1 = 0 ;
6803 char *kwnames[] = {
6804 (char *) "self",(char *) "vec", NULL
6805 };
6806
6807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6809 if (SWIG_arg_fail(1)) SWIG_fail;
6810 {
6811 arg2 = &temp2;
6812 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6813 }
6814 {
6815 PyThreadState* __tstate = wxPyBeginAllowThreads();
6816 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6817
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 {
6822 resultobj = SWIG_From_double((double)(result));
6823 }
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj;
6832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6833 wxPoint2D *arg2 = 0 ;
6834 double result;
6835 wxPoint2D temp2 ;
6836 PyObject * obj0 = 0 ;
6837 PyObject * obj1 = 0 ;
6838 char *kwnames[] = {
6839 (char *) "self",(char *) "vec", NULL
6840 };
6841
6842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6844 if (SWIG_arg_fail(1)) SWIG_fail;
6845 {
6846 arg2 = &temp2;
6847 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6848 }
6849 {
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6852
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 {
6857 resultobj = SWIG_From_double((double)(result));
6858 }
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6866 PyObject *resultobj;
6867 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6868 wxPoint2D result;
6869 PyObject * obj0 = 0 ;
6870 char *kwnames[] = {
6871 (char *) "self", NULL
6872 };
6873
6874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6876 if (SWIG_arg_fail(1)) SWIG_fail;
6877 {
6878 PyThreadState* __tstate = wxPyBeginAllowThreads();
6879 result = (arg1)->operator -();
6880
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 {
6885 wxPoint2D * resultptr;
6886 resultptr = new wxPoint2D((wxPoint2D &)(result));
6887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6888 }
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6896 PyObject *resultobj;
6897 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6898 wxPoint2D *arg2 = 0 ;
6899 wxPoint2D *result;
6900 wxPoint2D temp2 ;
6901 PyObject * obj0 = 0 ;
6902 PyObject * obj1 = 0 ;
6903 char *kwnames[] = {
6904 (char *) "self",(char *) "pt", NULL
6905 };
6906
6907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6909 if (SWIG_arg_fail(1)) SWIG_fail;
6910 {
6911 arg2 = &temp2;
6912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6913 }
6914 {
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 {
6917 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6918 result = (wxPoint2D *) &_result_ref;
6919 }
6920
6921 wxPyEndAllowThreads(__tstate);
6922 if (PyErr_Occurred()) SWIG_fail;
6923 }
6924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6932 PyObject *resultobj;
6933 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6934 wxPoint2D *arg2 = 0 ;
6935 wxPoint2D *result;
6936 wxPoint2D temp2 ;
6937 PyObject * obj0 = 0 ;
6938 PyObject * obj1 = 0 ;
6939 char *kwnames[] = {
6940 (char *) "self",(char *) "pt", NULL
6941 };
6942
6943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6945 if (SWIG_arg_fail(1)) SWIG_fail;
6946 {
6947 arg2 = &temp2;
6948 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6949 }
6950 {
6951 PyThreadState* __tstate = wxPyBeginAllowThreads();
6952 {
6953 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6954 result = (wxPoint2D *) &_result_ref;
6955 }
6956
6957 wxPyEndAllowThreads(__tstate);
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 static PyObject *_wrap_Point2D___imul__(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___imul__",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___idiv__(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___idiv__",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___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7040 PyObject *resultobj;
7041 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7042 wxPoint2D *arg2 = 0 ;
7043 bool 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___eq__",kwnames,&obj0,&obj1)) goto fail;
7052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
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 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7061
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 {
7066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7067 }
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7075 PyObject *resultobj;
7076 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7077 wxPoint2D *arg2 = 0 ;
7078 bool result;
7079 wxPoint2D temp2 ;
7080 PyObject * obj0 = 0 ;
7081 PyObject * obj1 = 0 ;
7082 char *kwnames[] = {
7083 (char *) "self",(char *) "pt", NULL
7084 };
7085
7086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7088 if (SWIG_arg_fail(1)) SWIG_fail;
7089 {
7090 arg2 = &temp2;
7091 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7092 }
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7096
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 {
7101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7102 }
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7110 PyObject *resultobj;
7111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7112 double arg2 ;
7113 PyObject * obj0 = 0 ;
7114 PyObject * obj1 = 0 ;
7115 char *kwnames[] = {
7116 (char *) "self",(char *) "m_x", NULL
7117 };
7118
7119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7121 if (SWIG_arg_fail(1)) SWIG_fail;
7122 {
7123 arg2 = (double)(SWIG_As_double(obj1));
7124 if (SWIG_arg_fail(2)) SWIG_fail;
7125 }
7126 if (arg1) (arg1)->m_x = arg2;
7127
7128 Py_INCREF(Py_None); resultobj = Py_None;
7129 return resultobj;
7130 fail:
7131 return NULL;
7132 }
7133
7134
7135 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7136 PyObject *resultobj;
7137 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7138 double result;
7139 PyObject * obj0 = 0 ;
7140 char *kwnames[] = {
7141 (char *) "self", NULL
7142 };
7143
7144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7146 if (SWIG_arg_fail(1)) SWIG_fail;
7147 result = (double) ((arg1)->m_x);
7148
7149 {
7150 resultobj = SWIG_From_double((double)(result));
7151 }
7152 return resultobj;
7153 fail:
7154 return NULL;
7155 }
7156
7157
7158 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7159 PyObject *resultobj;
7160 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7161 double arg2 ;
7162 PyObject * obj0 = 0 ;
7163 PyObject * obj1 = 0 ;
7164 char *kwnames[] = {
7165 (char *) "self",(char *) "m_y", NULL
7166 };
7167
7168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7170 if (SWIG_arg_fail(1)) SWIG_fail;
7171 {
7172 arg2 = (double)(SWIG_As_double(obj1));
7173 if (SWIG_arg_fail(2)) SWIG_fail;
7174 }
7175 if (arg1) (arg1)->m_y = arg2;
7176
7177 Py_INCREF(Py_None); resultobj = Py_None;
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj;
7186 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7187 double result;
7188 PyObject * obj0 = 0 ;
7189 char *kwnames[] = {
7190 (char *) "self", NULL
7191 };
7192
7193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7195 if (SWIG_arg_fail(1)) SWIG_fail;
7196 result = (double) ((arg1)->m_y);
7197
7198 {
7199 resultobj = SWIG_From_double((double)(result));
7200 }
7201 return resultobj;
7202 fail:
7203 return NULL;
7204 }
7205
7206
7207 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7208 PyObject *resultobj;
7209 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7210 double arg2 = (double) 0 ;
7211 double arg3 = (double) 0 ;
7212 PyObject * obj0 = 0 ;
7213 PyObject * obj1 = 0 ;
7214 PyObject * obj2 = 0 ;
7215 char *kwnames[] = {
7216 (char *) "self",(char *) "x",(char *) "y", NULL
7217 };
7218
7219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7221 if (SWIG_arg_fail(1)) SWIG_fail;
7222 if (obj1) {
7223 {
7224 arg2 = (double)(SWIG_As_double(obj1));
7225 if (SWIG_arg_fail(2)) SWIG_fail;
7226 }
7227 }
7228 if (obj2) {
7229 {
7230 arg3 = (double)(SWIG_As_double(obj2));
7231 if (SWIG_arg_fail(3)) SWIG_fail;
7232 }
7233 }
7234 {
7235 PyThreadState* __tstate = wxPyBeginAllowThreads();
7236 wxPoint2D_Set(arg1,arg2,arg3);
7237
7238 wxPyEndAllowThreads(__tstate);
7239 if (PyErr_Occurred()) SWIG_fail;
7240 }
7241 Py_INCREF(Py_None); resultobj = Py_None;
7242 return resultobj;
7243 fail:
7244 return NULL;
7245 }
7246
7247
7248 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7249 PyObject *resultobj;
7250 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7251 PyObject *result;
7252 PyObject * obj0 = 0 ;
7253 char *kwnames[] = {
7254 (char *) "self", NULL
7255 };
7256
7257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7259 if (SWIG_arg_fail(1)) SWIG_fail;
7260 {
7261 PyThreadState* __tstate = wxPyBeginAllowThreads();
7262 result = (PyObject *)wxPoint2D_Get(arg1);
7263
7264 wxPyEndAllowThreads(__tstate);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 resultobj = result;
7268 return resultobj;
7269 fail:
7270 return NULL;
7271 }
7272
7273
7274 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7275 PyObject *obj;
7276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7277 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7278 Py_INCREF(obj);
7279 return Py_BuildValue((char *)"");
7280 }
7281 static int _wrap_DefaultPosition_set(PyObject *) {
7282 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7283 return 1;
7284 }
7285
7286
7287 static PyObject *_wrap_DefaultPosition_get(void) {
7288 PyObject *pyobj;
7289
7290 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7291 return pyobj;
7292 }
7293
7294
7295 static int _wrap_DefaultSize_set(PyObject *) {
7296 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7297 return 1;
7298 }
7299
7300
7301 static PyObject *_wrap_DefaultSize_get(void) {
7302 PyObject *pyobj;
7303
7304 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7305 return pyobj;
7306 }
7307
7308
7309 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7310 PyObject *resultobj;
7311 PyObject *arg1 = (PyObject *) 0 ;
7312 wxPyInputStream *result;
7313 PyObject * obj0 = 0 ;
7314 char *kwnames[] = {
7315 (char *) "p", NULL
7316 };
7317
7318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7319 arg1 = obj0;
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7323
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7335 PyObject *resultobj;
7336 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7337 PyObject * obj0 = 0 ;
7338 char *kwnames[] = {
7339 (char *) "self", NULL
7340 };
7341
7342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7344 if (SWIG_arg_fail(1)) SWIG_fail;
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 delete arg1;
7348
7349 wxPyEndAllowThreads(__tstate);
7350 if (PyErr_Occurred()) SWIG_fail;
7351 }
7352 Py_INCREF(Py_None); resultobj = Py_None;
7353 return resultobj;
7354 fail:
7355 return NULL;
7356 }
7357
7358
7359 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7360 PyObject *resultobj;
7361 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7362 PyObject * obj0 = 0 ;
7363 char *kwnames[] = {
7364 (char *) "self", NULL
7365 };
7366
7367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7369 if (SWIG_arg_fail(1)) SWIG_fail;
7370 {
7371 PyThreadState* __tstate = wxPyBeginAllowThreads();
7372 (arg1)->close();
7373
7374 wxPyEndAllowThreads(__tstate);
7375 if (PyErr_Occurred()) SWIG_fail;
7376 }
7377 Py_INCREF(Py_None); resultobj = Py_None;
7378 return resultobj;
7379 fail:
7380 return NULL;
7381 }
7382
7383
7384 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7385 PyObject *resultobj;
7386 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7387 PyObject * obj0 = 0 ;
7388 char *kwnames[] = {
7389 (char *) "self", NULL
7390 };
7391
7392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7394 if (SWIG_arg_fail(1)) SWIG_fail;
7395 {
7396 PyThreadState* __tstate = wxPyBeginAllowThreads();
7397 (arg1)->flush();
7398
7399 wxPyEndAllowThreads(__tstate);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 Py_INCREF(Py_None); resultobj = Py_None;
7403 return resultobj;
7404 fail:
7405 return NULL;
7406 }
7407
7408
7409 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7410 PyObject *resultobj;
7411 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7412 bool result;
7413 PyObject * obj0 = 0 ;
7414 char *kwnames[] = {
7415 (char *) "self", NULL
7416 };
7417
7418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7420 if (SWIG_arg_fail(1)) SWIG_fail;
7421 {
7422 PyThreadState* __tstate = wxPyBeginAllowThreads();
7423 result = (bool)(arg1)->eof();
7424
7425 wxPyEndAllowThreads(__tstate);
7426 if (PyErr_Occurred()) SWIG_fail;
7427 }
7428 {
7429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7430 }
7431 return resultobj;
7432 fail:
7433 return NULL;
7434 }
7435
7436
7437 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7438 PyObject *resultobj;
7439 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7440 int arg2 = (int) -1 ;
7441 PyObject *result;
7442 PyObject * obj0 = 0 ;
7443 PyObject * obj1 = 0 ;
7444 char *kwnames[] = {
7445 (char *) "self",(char *) "size", NULL
7446 };
7447
7448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7450 if (SWIG_arg_fail(1)) SWIG_fail;
7451 if (obj1) {
7452 {
7453 arg2 = (int)(SWIG_As_int(obj1));
7454 if (SWIG_arg_fail(2)) SWIG_fail;
7455 }
7456 }
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = (PyObject *)(arg1)->read(arg2);
7460
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 resultobj = result;
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj;
7473 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7474 int arg2 = (int) -1 ;
7475 PyObject *result;
7476 PyObject * obj0 = 0 ;
7477 PyObject * obj1 = 0 ;
7478 char *kwnames[] = {
7479 (char *) "self",(char *) "size", NULL
7480 };
7481
7482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7484 if (SWIG_arg_fail(1)) SWIG_fail;
7485 if (obj1) {
7486 {
7487 arg2 = (int)(SWIG_As_int(obj1));
7488 if (SWIG_arg_fail(2)) SWIG_fail;
7489 }
7490 }
7491 {
7492 PyThreadState* __tstate = wxPyBeginAllowThreads();
7493 result = (PyObject *)(arg1)->readline(arg2);
7494
7495 wxPyEndAllowThreads(__tstate);
7496 if (PyErr_Occurred()) SWIG_fail;
7497 }
7498 resultobj = result;
7499 return resultobj;
7500 fail:
7501 return NULL;
7502 }
7503
7504
7505 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7506 PyObject *resultobj;
7507 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7508 int arg2 = (int) -1 ;
7509 PyObject *result;
7510 PyObject * obj0 = 0 ;
7511 PyObject * obj1 = 0 ;
7512 char *kwnames[] = {
7513 (char *) "self",(char *) "sizehint", NULL
7514 };
7515
7516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7518 if (SWIG_arg_fail(1)) SWIG_fail;
7519 if (obj1) {
7520 {
7521 arg2 = (int)(SWIG_As_int(obj1));
7522 if (SWIG_arg_fail(2)) SWIG_fail;
7523 }
7524 }
7525 {
7526 PyThreadState* __tstate = wxPyBeginAllowThreads();
7527 result = (PyObject *)(arg1)->readlines(arg2);
7528
7529 wxPyEndAllowThreads(__tstate);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 resultobj = result;
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj;
7541 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7542 int arg2 ;
7543 int arg3 = (int) 0 ;
7544 PyObject * obj0 = 0 ;
7545 PyObject * obj1 = 0 ;
7546 PyObject * obj2 = 0 ;
7547 char *kwnames[] = {
7548 (char *) "self",(char *) "offset",(char *) "whence", NULL
7549 };
7550
7551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7553 if (SWIG_arg_fail(1)) SWIG_fail;
7554 {
7555 arg2 = (int)(SWIG_As_int(obj1));
7556 if (SWIG_arg_fail(2)) SWIG_fail;
7557 }
7558 if (obj2) {
7559 {
7560 arg3 = (int)(SWIG_As_int(obj2));
7561 if (SWIG_arg_fail(3)) SWIG_fail;
7562 }
7563 }
7564 {
7565 PyThreadState* __tstate = wxPyBeginAllowThreads();
7566 (arg1)->seek(arg2,arg3);
7567
7568 wxPyEndAllowThreads(__tstate);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 Py_INCREF(Py_None); resultobj = Py_None;
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj;
7580 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7581 int result;
7582 PyObject * obj0 = 0 ;
7583 char *kwnames[] = {
7584 (char *) "self", NULL
7585 };
7586
7587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7589 if (SWIG_arg_fail(1)) SWIG_fail;
7590 {
7591 PyThreadState* __tstate = wxPyBeginAllowThreads();
7592 result = (int)(arg1)->tell();
7593
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = SWIG_From_int((int)(result));
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj;
7608 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7609 char result;
7610 PyObject * obj0 = 0 ;
7611 char *kwnames[] = {
7612 (char *) "self", NULL
7613 };
7614
7615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7617 if (SWIG_arg_fail(1)) SWIG_fail;
7618 {
7619 PyThreadState* __tstate = wxPyBeginAllowThreads();
7620 result = (char)(arg1)->Peek();
7621
7622 wxPyEndAllowThreads(__tstate);
7623 if (PyErr_Occurred()) SWIG_fail;
7624 }
7625 {
7626 resultobj = SWIG_From_char((char)(result));
7627 }
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj;
7636 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7637 char result;
7638 PyObject * obj0 = 0 ;
7639 char *kwnames[] = {
7640 (char *) "self", NULL
7641 };
7642
7643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7645 if (SWIG_arg_fail(1)) SWIG_fail;
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (char)(arg1)->GetC();
7649
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 {
7654 resultobj = SWIG_From_char((char)(result));
7655 }
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj;
7664 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7665 size_t result;
7666 PyObject * obj0 = 0 ;
7667 char *kwnames[] = {
7668 (char *) "self", NULL
7669 };
7670
7671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7673 if (SWIG_arg_fail(1)) SWIG_fail;
7674 {
7675 PyThreadState* __tstate = wxPyBeginAllowThreads();
7676 result = (size_t)(arg1)->LastRead();
7677
7678 wxPyEndAllowThreads(__tstate);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 {
7682 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7683 }
7684 return resultobj;
7685 fail:
7686 return NULL;
7687 }
7688
7689
7690 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj;
7692 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7693 bool result;
7694 PyObject * obj0 = 0 ;
7695 char *kwnames[] = {
7696 (char *) "self", NULL
7697 };
7698
7699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7701 if (SWIG_arg_fail(1)) SWIG_fail;
7702 {
7703 PyThreadState* __tstate = wxPyBeginAllowThreads();
7704 result = (bool)(arg1)->CanRead();
7705
7706 wxPyEndAllowThreads(__tstate);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 {
7710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7711 }
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj;
7720 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7721 bool result;
7722 PyObject * obj0 = 0 ;
7723 char *kwnames[] = {
7724 (char *) "self", NULL
7725 };
7726
7727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7729 if (SWIG_arg_fail(1)) SWIG_fail;
7730 {
7731 PyThreadState* __tstate = wxPyBeginAllowThreads();
7732 result = (bool)(arg1)->Eof();
7733
7734 wxPyEndAllowThreads(__tstate);
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 {
7738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7739 }
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7747 PyObject *resultobj;
7748 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7749 char arg2 ;
7750 bool result;
7751 PyObject * obj0 = 0 ;
7752 PyObject * obj1 = 0 ;
7753 char *kwnames[] = {
7754 (char *) "self",(char *) "c", NULL
7755 };
7756
7757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7759 if (SWIG_arg_fail(1)) SWIG_fail;
7760 {
7761 arg2 = (char)(SWIG_As_char(obj1));
7762 if (SWIG_arg_fail(2)) SWIG_fail;
7763 }
7764 {
7765 PyThreadState* __tstate = wxPyBeginAllowThreads();
7766 result = (bool)(arg1)->Ungetch(arg2);
7767
7768 wxPyEndAllowThreads(__tstate);
7769 if (PyErr_Occurred()) SWIG_fail;
7770 }
7771 {
7772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7773 }
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj;
7782 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7783 long arg2 ;
7784 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7785 long result;
7786 PyObject * obj0 = 0 ;
7787 PyObject * obj1 = 0 ;
7788 PyObject * obj2 = 0 ;
7789 char *kwnames[] = {
7790 (char *) "self",(char *) "pos",(char *) "mode", NULL
7791 };
7792
7793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7795 if (SWIG_arg_fail(1)) SWIG_fail;
7796 {
7797 arg2 = (long)(SWIG_As_long(obj1));
7798 if (SWIG_arg_fail(2)) SWIG_fail;
7799 }
7800 if (obj2) {
7801 {
7802 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7803 if (SWIG_arg_fail(3)) SWIG_fail;
7804 }
7805 }
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7809
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 {
7814 resultobj = SWIG_From_long((long)(result));
7815 }
7816 return resultobj;
7817 fail:
7818 return NULL;
7819 }
7820
7821
7822 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7823 PyObject *resultobj;
7824 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7825 long result;
7826 PyObject * obj0 = 0 ;
7827 char *kwnames[] = {
7828 (char *) "self", NULL
7829 };
7830
7831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7833 if (SWIG_arg_fail(1)) SWIG_fail;
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (long)(arg1)->TellI();
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = SWIG_From_long((long)(result));
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7851 PyObject *obj;
7852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7853 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7854 Py_INCREF(obj);
7855 return Py_BuildValue((char *)"");
7856 }
7857 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7858 PyObject *resultobj;
7859 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7860 PyObject *arg2 = (PyObject *) 0 ;
7861 PyObject * obj0 = 0 ;
7862 PyObject * obj1 = 0 ;
7863 char *kwnames[] = {
7864 (char *) "self",(char *) "obj", NULL
7865 };
7866
7867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7869 if (SWIG_arg_fail(1)) SWIG_fail;
7870 arg2 = obj1;
7871 {
7872 PyThreadState* __tstate = wxPyBeginAllowThreads();
7873 wxOutputStream_write(arg1,arg2);
7874
7875 wxPyEndAllowThreads(__tstate);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 Py_INCREF(Py_None); resultobj = Py_None;
7879 return resultobj;
7880 fail:
7881 return NULL;
7882 }
7883
7884
7885 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7886 PyObject *obj;
7887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7888 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7889 Py_INCREF(obj);
7890 return Py_BuildValue((char *)"");
7891 }
7892 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj;
7894 wxInputStream *arg1 = (wxInputStream *) 0 ;
7895 wxString *arg2 = 0 ;
7896 wxString *arg3 = 0 ;
7897 wxString *arg4 = 0 ;
7898 wxDateTime arg5 ;
7899 wxFSFile *result;
7900 wxPyInputStream *temp1 ;
7901 bool temp2 = false ;
7902 bool temp3 = false ;
7903 bool temp4 = false ;
7904 PyObject * obj0 = 0 ;
7905 PyObject * obj1 = 0 ;
7906 PyObject * obj2 = 0 ;
7907 PyObject * obj3 = 0 ;
7908 PyObject * obj4 = 0 ;
7909 char *kwnames[] = {
7910 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7911 };
7912
7913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7914 {
7915 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7916 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7917 } else {
7918 PyErr_Clear(); // clear the failure of the wxPyConvert above
7919 arg1 = wxPyCBInputStream_create(obj0, true);
7920 if (arg1 == NULL) {
7921 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7922 SWIG_fail;
7923 }
7924 }
7925 }
7926 {
7927 arg2 = wxString_in_helper(obj1);
7928 if (arg2 == NULL) SWIG_fail;
7929 temp2 = true;
7930 }
7931 {
7932 arg3 = wxString_in_helper(obj2);
7933 if (arg3 == NULL) SWIG_fail;
7934 temp3 = true;
7935 }
7936 {
7937 arg4 = wxString_in_helper(obj3);
7938 if (arg4 == NULL) SWIG_fail;
7939 temp4 = true;
7940 }
7941 {
7942 wxDateTime * argp;
7943 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7944 if (SWIG_arg_fail(5)) SWIG_fail;
7945 if (argp == NULL) {
7946 SWIG_null_ref("wxDateTime");
7947 }
7948 if (SWIG_arg_fail(5)) SWIG_fail;
7949 arg5 = *argp;
7950 }
7951 {
7952 PyThreadState* __tstate = wxPyBeginAllowThreads();
7953 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7954
7955 wxPyEndAllowThreads(__tstate);
7956 if (PyErr_Occurred()) SWIG_fail;
7957 }
7958 {
7959 resultobj = wxPyMake_wxObject(result, 1);
7960 }
7961 {
7962 if (temp2)
7963 delete arg2;
7964 }
7965 {
7966 if (temp3)
7967 delete arg3;
7968 }
7969 {
7970 if (temp4)
7971 delete arg4;
7972 }
7973 return resultobj;
7974 fail:
7975 {
7976 if (temp2)
7977 delete arg2;
7978 }
7979 {
7980 if (temp3)
7981 delete arg3;
7982 }
7983 {
7984 if (temp4)
7985 delete arg4;
7986 }
7987 return NULL;
7988 }
7989
7990
7991 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7992 PyObject *resultobj;
7993 wxFSFile *arg1 = (wxFSFile *) 0 ;
7994 PyObject * obj0 = 0 ;
7995 char *kwnames[] = {
7996 (char *) "self", NULL
7997 };
7998
7999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8001 if (SWIG_arg_fail(1)) SWIG_fail;
8002 {
8003 PyThreadState* __tstate = wxPyBeginAllowThreads();
8004 delete arg1;
8005
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 Py_INCREF(Py_None); resultobj = Py_None;
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8017 PyObject *resultobj;
8018 wxFSFile *arg1 = (wxFSFile *) 0 ;
8019 wxInputStream *result;
8020 PyObject * obj0 = 0 ;
8021 char *kwnames[] = {
8022 (char *) "self", NULL
8023 };
8024
8025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8027 if (SWIG_arg_fail(1)) SWIG_fail;
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 result = (wxInputStream *)(arg1)->GetStream();
8031
8032 wxPyEndAllowThreads(__tstate);
8033 if (PyErr_Occurred()) SWIG_fail;
8034 }
8035 {
8036 wxPyInputStream * _ptr = NULL;
8037
8038 if (result) {
8039 _ptr = new wxPyInputStream(result);
8040 }
8041 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8042 }
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8050 PyObject *resultobj;
8051 wxFSFile *arg1 = (wxFSFile *) 0 ;
8052 wxString *result;
8053 PyObject * obj0 = 0 ;
8054 char *kwnames[] = {
8055 (char *) "self", NULL
8056 };
8057
8058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8060 if (SWIG_arg_fail(1)) SWIG_fail;
8061 {
8062 PyThreadState* __tstate = wxPyBeginAllowThreads();
8063 {
8064 wxString const &_result_ref = (arg1)->GetMimeType();
8065 result = (wxString *) &_result_ref;
8066 }
8067
8068 wxPyEndAllowThreads(__tstate);
8069 if (PyErr_Occurred()) SWIG_fail;
8070 }
8071 {
8072 #if wxUSE_UNICODE
8073 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8074 #else
8075 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8076 #endif
8077 }
8078 return resultobj;
8079 fail:
8080 return NULL;
8081 }
8082
8083
8084 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8085 PyObject *resultobj;
8086 wxFSFile *arg1 = (wxFSFile *) 0 ;
8087 wxString *result;
8088 PyObject * obj0 = 0 ;
8089 char *kwnames[] = {
8090 (char *) "self", NULL
8091 };
8092
8093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8095 if (SWIG_arg_fail(1)) SWIG_fail;
8096 {
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 {
8099 wxString const &_result_ref = (arg1)->GetLocation();
8100 result = (wxString *) &_result_ref;
8101 }
8102
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 {
8107 #if wxUSE_UNICODE
8108 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8109 #else
8110 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8111 #endif
8112 }
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj;
8121 wxFSFile *arg1 = (wxFSFile *) 0 ;
8122 wxString *result;
8123 PyObject * obj0 = 0 ;
8124 char *kwnames[] = {
8125 (char *) "self", NULL
8126 };
8127
8128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8130 if (SWIG_arg_fail(1)) SWIG_fail;
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 {
8134 wxString const &_result_ref = (arg1)->GetAnchor();
8135 result = (wxString *) &_result_ref;
8136 }
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 {
8142 #if wxUSE_UNICODE
8143 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8144 #else
8145 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8146 #endif
8147 }
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxFSFile *arg1 = (wxFSFile *) 0 ;
8157 wxDateTime result;
8158 PyObject * obj0 = 0 ;
8159 char *kwnames[] = {
8160 (char *) "self", NULL
8161 };
8162
8163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8165 if (SWIG_arg_fail(1)) SWIG_fail;
8166 {
8167 PyThreadState* __tstate = wxPyBeginAllowThreads();
8168 result = (arg1)->GetModificationTime();
8169
8170 wxPyEndAllowThreads(__tstate);
8171 if (PyErr_Occurred()) SWIG_fail;
8172 }
8173 {
8174 wxDateTime * resultptr;
8175 resultptr = new wxDateTime((wxDateTime &)(result));
8176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8177 }
8178 return resultobj;
8179 fail:
8180 return NULL;
8181 }
8182
8183
8184 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8185 PyObject *obj;
8186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8187 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8188 Py_INCREF(obj);
8189 return Py_BuildValue((char *)"");
8190 }
8191 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8192 PyObject *obj;
8193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8194 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8195 Py_INCREF(obj);
8196 return Py_BuildValue((char *)"");
8197 }
8198 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8199 PyObject *resultobj;
8200 wxPyFileSystemHandler *result;
8201 char *kwnames[] = {
8202 NULL
8203 };
8204
8205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8206 {
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8209
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8221 PyObject *resultobj;
8222 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8223 PyObject *arg2 = (PyObject *) 0 ;
8224 PyObject *arg3 = (PyObject *) 0 ;
8225 PyObject * obj0 = 0 ;
8226 PyObject * obj1 = 0 ;
8227 PyObject * obj2 = 0 ;
8228 char *kwnames[] = {
8229 (char *) "self",(char *) "self",(char *) "_class", NULL
8230 };
8231
8232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8234 if (SWIG_arg_fail(1)) SWIG_fail;
8235 arg2 = obj1;
8236 arg3 = obj2;
8237 {
8238 PyThreadState* __tstate = wxPyBeginAllowThreads();
8239 (arg1)->_setCallbackInfo(arg2,arg3);
8240
8241 wxPyEndAllowThreads(__tstate);
8242 if (PyErr_Occurred()) SWIG_fail;
8243 }
8244 Py_INCREF(Py_None); resultobj = Py_None;
8245 return resultobj;
8246 fail:
8247 return NULL;
8248 }
8249
8250
8251 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8252 PyObject *resultobj;
8253 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8254 wxString *arg2 = 0 ;
8255 bool result;
8256 bool temp2 = false ;
8257 PyObject * obj0 = 0 ;
8258 PyObject * obj1 = 0 ;
8259 char *kwnames[] = {
8260 (char *) "self",(char *) "location", NULL
8261 };
8262
8263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8265 if (SWIG_arg_fail(1)) SWIG_fail;
8266 {
8267 arg2 = wxString_in_helper(obj1);
8268 if (arg2 == NULL) SWIG_fail;
8269 temp2 = true;
8270 }
8271 {
8272 PyThreadState* __tstate = wxPyBeginAllowThreads();
8273 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8274
8275 wxPyEndAllowThreads(__tstate);
8276 if (PyErr_Occurred()) SWIG_fail;
8277 }
8278 {
8279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8280 }
8281 {
8282 if (temp2)
8283 delete arg2;
8284 }
8285 return resultobj;
8286 fail:
8287 {
8288 if (temp2)
8289 delete arg2;
8290 }
8291 return NULL;
8292 }
8293
8294
8295 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj;
8297 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8298 wxFileSystem *arg2 = 0 ;
8299 wxString *arg3 = 0 ;
8300 wxFSFile *result;
8301 bool temp3 = false ;
8302 PyObject * obj0 = 0 ;
8303 PyObject * obj1 = 0 ;
8304 PyObject * obj2 = 0 ;
8305 char *kwnames[] = {
8306 (char *) "self",(char *) "fs",(char *) "location", NULL
8307 };
8308
8309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8311 if (SWIG_arg_fail(1)) SWIG_fail;
8312 {
8313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8314 if (SWIG_arg_fail(2)) SWIG_fail;
8315 if (arg2 == NULL) {
8316 SWIG_null_ref("wxFileSystem");
8317 }
8318 if (SWIG_arg_fail(2)) SWIG_fail;
8319 }
8320 {
8321 arg3 = wxString_in_helper(obj2);
8322 if (arg3 == NULL) SWIG_fail;
8323 temp3 = true;
8324 }
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8328
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 {
8333 resultobj = wxPyMake_wxObject(result, 1);
8334 }
8335 {
8336 if (temp3)
8337 delete arg3;
8338 }
8339 return resultobj;
8340 fail:
8341 {
8342 if (temp3)
8343 delete arg3;
8344 }
8345 return NULL;
8346 }
8347
8348
8349 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8350 PyObject *resultobj;
8351 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8352 wxString *arg2 = 0 ;
8353 int arg3 = (int) 0 ;
8354 wxString result;
8355 bool temp2 = false ;
8356 PyObject * obj0 = 0 ;
8357 PyObject * obj1 = 0 ;
8358 PyObject * obj2 = 0 ;
8359 char *kwnames[] = {
8360 (char *) "self",(char *) "spec",(char *) "flags", NULL
8361 };
8362
8363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8365 if (SWIG_arg_fail(1)) SWIG_fail;
8366 {
8367 arg2 = wxString_in_helper(obj1);
8368 if (arg2 == NULL) SWIG_fail;
8369 temp2 = true;
8370 }
8371 if (obj2) {
8372 {
8373 arg3 = (int)(SWIG_As_int(obj2));
8374 if (SWIG_arg_fail(3)) SWIG_fail;
8375 }
8376 }
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8380
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 {
8385 #if wxUSE_UNICODE
8386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8387 #else
8388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8389 #endif
8390 }
8391 {
8392 if (temp2)
8393 delete arg2;
8394 }
8395 return resultobj;
8396 fail:
8397 {
8398 if (temp2)
8399 delete arg2;
8400 }
8401 return NULL;
8402 }
8403
8404
8405 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8406 PyObject *resultobj;
8407 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8408 wxString result;
8409 PyObject * obj0 = 0 ;
8410 char *kwnames[] = {
8411 (char *) "self", NULL
8412 };
8413
8414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8416 if (SWIG_arg_fail(1)) SWIG_fail;
8417 {
8418 PyThreadState* __tstate = wxPyBeginAllowThreads();
8419 result = (arg1)->FindNext();
8420
8421 wxPyEndAllowThreads(__tstate);
8422 if (PyErr_Occurred()) SWIG_fail;
8423 }
8424 {
8425 #if wxUSE_UNICODE
8426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8427 #else
8428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8429 #endif
8430 }
8431 return resultobj;
8432 fail:
8433 return NULL;
8434 }
8435
8436
8437 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8438 PyObject *resultobj;
8439 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8440 wxString *arg2 = 0 ;
8441 wxString result;
8442 bool temp2 = false ;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char *kwnames[] = {
8446 (char *) "self",(char *) "location", NULL
8447 };
8448
8449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8451 if (SWIG_arg_fail(1)) SWIG_fail;
8452 {
8453 arg2 = wxString_in_helper(obj1);
8454 if (arg2 == NULL) SWIG_fail;
8455 temp2 = true;
8456 }
8457 {
8458 PyThreadState* __tstate = wxPyBeginAllowThreads();
8459 result = (arg1)->GetProtocol((wxString const &)*arg2);
8460
8461 wxPyEndAllowThreads(__tstate);
8462 if (PyErr_Occurred()) SWIG_fail;
8463 }
8464 {
8465 #if wxUSE_UNICODE
8466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8467 #else
8468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8469 #endif
8470 }
8471 {
8472 if (temp2)
8473 delete arg2;
8474 }
8475 return resultobj;
8476 fail:
8477 {
8478 if (temp2)
8479 delete arg2;
8480 }
8481 return NULL;
8482 }
8483
8484
8485 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8486 PyObject *resultobj;
8487 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8488 wxString *arg2 = 0 ;
8489 wxString result;
8490 bool temp2 = false ;
8491 PyObject * obj0 = 0 ;
8492 PyObject * obj1 = 0 ;
8493 char *kwnames[] = {
8494 (char *) "self",(char *) "location", NULL
8495 };
8496
8497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8499 if (SWIG_arg_fail(1)) SWIG_fail;
8500 {
8501 arg2 = wxString_in_helper(obj1);
8502 if (arg2 == NULL) SWIG_fail;
8503 temp2 = true;
8504 }
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8508
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 {
8513 #if wxUSE_UNICODE
8514 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8515 #else
8516 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8517 #endif
8518 }
8519 {
8520 if (temp2)
8521 delete arg2;
8522 }
8523 return resultobj;
8524 fail:
8525 {
8526 if (temp2)
8527 delete arg2;
8528 }
8529 return NULL;
8530 }
8531
8532
8533 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8534 PyObject *resultobj;
8535 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8536 wxString *arg2 = 0 ;
8537 wxString result;
8538 bool temp2 = false ;
8539 PyObject * obj0 = 0 ;
8540 PyObject * obj1 = 0 ;
8541 char *kwnames[] = {
8542 (char *) "self",(char *) "location", NULL
8543 };
8544
8545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8547 if (SWIG_arg_fail(1)) SWIG_fail;
8548 {
8549 arg2 = wxString_in_helper(obj1);
8550 if (arg2 == NULL) SWIG_fail;
8551 temp2 = true;
8552 }
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 result = (arg1)->GetAnchor((wxString const &)*arg2);
8556
8557 wxPyEndAllowThreads(__tstate);
8558 if (PyErr_Occurred()) SWIG_fail;
8559 }
8560 {
8561 #if wxUSE_UNICODE
8562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8563 #else
8564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8565 #endif
8566 }
8567 {
8568 if (temp2)
8569 delete arg2;
8570 }
8571 return resultobj;
8572 fail:
8573 {
8574 if (temp2)
8575 delete arg2;
8576 }
8577 return NULL;
8578 }
8579
8580
8581 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8582 PyObject *resultobj;
8583 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8584 wxString *arg2 = 0 ;
8585 wxString result;
8586 bool temp2 = false ;
8587 PyObject * obj0 = 0 ;
8588 PyObject * obj1 = 0 ;
8589 char *kwnames[] = {
8590 (char *) "self",(char *) "location", NULL
8591 };
8592
8593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8595 if (SWIG_arg_fail(1)) SWIG_fail;
8596 {
8597 arg2 = wxString_in_helper(obj1);
8598 if (arg2 == NULL) SWIG_fail;
8599 temp2 = true;
8600 }
8601 {
8602 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8604
8605 wxPyEndAllowThreads(__tstate);
8606 if (PyErr_Occurred()) SWIG_fail;
8607 }
8608 {
8609 #if wxUSE_UNICODE
8610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8611 #else
8612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8613 #endif
8614 }
8615 {
8616 if (temp2)
8617 delete arg2;
8618 }
8619 return resultobj;
8620 fail:
8621 {
8622 if (temp2)
8623 delete arg2;
8624 }
8625 return NULL;
8626 }
8627
8628
8629 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8630 PyObject *resultobj;
8631 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8632 wxString *arg2 = 0 ;
8633 wxString result;
8634 bool temp2 = false ;
8635 PyObject * obj0 = 0 ;
8636 PyObject * obj1 = 0 ;
8637 char *kwnames[] = {
8638 (char *) "self",(char *) "location", NULL
8639 };
8640
8641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8643 if (SWIG_arg_fail(1)) SWIG_fail;
8644 {
8645 arg2 = wxString_in_helper(obj1);
8646 if (arg2 == NULL) SWIG_fail;
8647 temp2 = true;
8648 }
8649 {
8650 PyThreadState* __tstate = wxPyBeginAllowThreads();
8651 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8652
8653 wxPyEndAllowThreads(__tstate);
8654 if (PyErr_Occurred()) SWIG_fail;
8655 }
8656 {
8657 #if wxUSE_UNICODE
8658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8659 #else
8660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8661 #endif
8662 }
8663 {
8664 if (temp2)
8665 delete arg2;
8666 }
8667 return resultobj;
8668 fail:
8669 {
8670 if (temp2)
8671 delete arg2;
8672 }
8673 return NULL;
8674 }
8675
8676
8677 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8678 PyObject *obj;
8679 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8680 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8681 Py_INCREF(obj);
8682 return Py_BuildValue((char *)"");
8683 }
8684 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8685 PyObject *resultobj;
8686 wxFileSystem *result;
8687 char *kwnames[] = {
8688 NULL
8689 };
8690
8691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8692 {
8693 PyThreadState* __tstate = wxPyBeginAllowThreads();
8694 result = (wxFileSystem *)new wxFileSystem();
8695
8696 wxPyEndAllowThreads(__tstate);
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 {
8700 resultobj = wxPyMake_wxObject(result, 1);
8701 }
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8709 PyObject *resultobj;
8710 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8711 PyObject * obj0 = 0 ;
8712 char *kwnames[] = {
8713 (char *) "self", NULL
8714 };
8715
8716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8718 if (SWIG_arg_fail(1)) SWIG_fail;
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 delete arg1;
8722
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 Py_INCREF(Py_None); resultobj = Py_None;
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8734 PyObject *resultobj;
8735 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8736 wxString *arg2 = 0 ;
8737 bool arg3 = (bool) false ;
8738 bool temp2 = false ;
8739 PyObject * obj0 = 0 ;
8740 PyObject * obj1 = 0 ;
8741 PyObject * obj2 = 0 ;
8742 char *kwnames[] = {
8743 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8744 };
8745
8746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8748 if (SWIG_arg_fail(1)) SWIG_fail;
8749 {
8750 arg2 = wxString_in_helper(obj1);
8751 if (arg2 == NULL) SWIG_fail;
8752 temp2 = true;
8753 }
8754 if (obj2) {
8755 {
8756 arg3 = (bool)(SWIG_As_bool(obj2));
8757 if (SWIG_arg_fail(3)) SWIG_fail;
8758 }
8759 }
8760 {
8761 PyThreadState* __tstate = wxPyBeginAllowThreads();
8762 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8763
8764 wxPyEndAllowThreads(__tstate);
8765 if (PyErr_Occurred()) SWIG_fail;
8766 }
8767 Py_INCREF(Py_None); resultobj = Py_None;
8768 {
8769 if (temp2)
8770 delete arg2;
8771 }
8772 return resultobj;
8773 fail:
8774 {
8775 if (temp2)
8776 delete arg2;
8777 }
8778 return NULL;
8779 }
8780
8781
8782 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj;
8784 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8785 wxString result;
8786 PyObject * obj0 = 0 ;
8787 char *kwnames[] = {
8788 (char *) "self", NULL
8789 };
8790
8791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8793 if (SWIG_arg_fail(1)) SWIG_fail;
8794 {
8795 PyThreadState* __tstate = wxPyBeginAllowThreads();
8796 result = (arg1)->GetPath();
8797
8798 wxPyEndAllowThreads(__tstate);
8799 if (PyErr_Occurred()) SWIG_fail;
8800 }
8801 {
8802 #if wxUSE_UNICODE
8803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8804 #else
8805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8806 #endif
8807 }
8808 return resultobj;
8809 fail:
8810 return NULL;
8811 }
8812
8813
8814 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8815 PyObject *resultobj;
8816 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8817 wxString *arg2 = 0 ;
8818 wxFSFile *result;
8819 bool temp2 = false ;
8820 PyObject * obj0 = 0 ;
8821 PyObject * obj1 = 0 ;
8822 char *kwnames[] = {
8823 (char *) "self",(char *) "location", NULL
8824 };
8825
8826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8828 if (SWIG_arg_fail(1)) SWIG_fail;
8829 {
8830 arg2 = wxString_in_helper(obj1);
8831 if (arg2 == NULL) SWIG_fail;
8832 temp2 = true;
8833 }
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8837
8838 wxPyEndAllowThreads(__tstate);
8839 if (PyErr_Occurred()) SWIG_fail;
8840 }
8841 {
8842 resultobj = wxPyMake_wxObject(result, 1);
8843 }
8844 {
8845 if (temp2)
8846 delete arg2;
8847 }
8848 return resultobj;
8849 fail:
8850 {
8851 if (temp2)
8852 delete arg2;
8853 }
8854 return NULL;
8855 }
8856
8857
8858 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj;
8860 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8861 wxString *arg2 = 0 ;
8862 int arg3 = (int) 0 ;
8863 wxString result;
8864 bool temp2 = false ;
8865 PyObject * obj0 = 0 ;
8866 PyObject * obj1 = 0 ;
8867 PyObject * obj2 = 0 ;
8868 char *kwnames[] = {
8869 (char *) "self",(char *) "spec",(char *) "flags", NULL
8870 };
8871
8872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8874 if (SWIG_arg_fail(1)) SWIG_fail;
8875 {
8876 arg2 = wxString_in_helper(obj1);
8877 if (arg2 == NULL) SWIG_fail;
8878 temp2 = true;
8879 }
8880 if (obj2) {
8881 {
8882 arg3 = (int)(SWIG_As_int(obj2));
8883 if (SWIG_arg_fail(3)) SWIG_fail;
8884 }
8885 }
8886 {
8887 PyThreadState* __tstate = wxPyBeginAllowThreads();
8888 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8889
8890 wxPyEndAllowThreads(__tstate);
8891 if (PyErr_Occurred()) SWIG_fail;
8892 }
8893 {
8894 #if wxUSE_UNICODE
8895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8896 #else
8897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8898 #endif
8899 }
8900 {
8901 if (temp2)
8902 delete arg2;
8903 }
8904 return resultobj;
8905 fail:
8906 {
8907 if (temp2)
8908 delete arg2;
8909 }
8910 return NULL;
8911 }
8912
8913
8914 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj;
8916 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8917 wxString result;
8918 PyObject * obj0 = 0 ;
8919 char *kwnames[] = {
8920 (char *) "self", NULL
8921 };
8922
8923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8925 if (SWIG_arg_fail(1)) SWIG_fail;
8926 {
8927 PyThreadState* __tstate = wxPyBeginAllowThreads();
8928 result = (arg1)->FindNext();
8929
8930 wxPyEndAllowThreads(__tstate);
8931 if (PyErr_Occurred()) SWIG_fail;
8932 }
8933 {
8934 #if wxUSE_UNICODE
8935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8936 #else
8937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8938 #endif
8939 }
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8947 PyObject *resultobj;
8948 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8949 PyObject * obj0 = 0 ;
8950 char *kwnames[] = {
8951 (char *) "handler", NULL
8952 };
8953
8954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8956 if (SWIG_arg_fail(1)) SWIG_fail;
8957 {
8958 PyThreadState* __tstate = wxPyBeginAllowThreads();
8959 wxFileSystem::AddHandler(arg1);
8960
8961 wxPyEndAllowThreads(__tstate);
8962 if (PyErr_Occurred()) SWIG_fail;
8963 }
8964 Py_INCREF(Py_None); resultobj = Py_None;
8965 return resultobj;
8966 fail:
8967 return NULL;
8968 }
8969
8970
8971 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8972 PyObject *resultobj;
8973 char *kwnames[] = {
8974 NULL
8975 };
8976
8977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8978 {
8979 PyThreadState* __tstate = wxPyBeginAllowThreads();
8980 wxFileSystem::CleanUpHandlers();
8981
8982 wxPyEndAllowThreads(__tstate);
8983 if (PyErr_Occurred()) SWIG_fail;
8984 }
8985 Py_INCREF(Py_None); resultobj = Py_None;
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8993 PyObject *resultobj;
8994 wxString *arg1 = 0 ;
8995 wxString result;
8996 bool temp1 = false ;
8997 PyObject * obj0 = 0 ;
8998 char *kwnames[] = {
8999 (char *) "filename", NULL
9000 };
9001
9002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9003 {
9004 arg1 = wxString_in_helper(obj0);
9005 if (arg1 == NULL) SWIG_fail;
9006 temp1 = true;
9007 }
9008 {
9009 PyThreadState* __tstate = wxPyBeginAllowThreads();
9010 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9011
9012 wxPyEndAllowThreads(__tstate);
9013 if (PyErr_Occurred()) SWIG_fail;
9014 }
9015 {
9016 #if wxUSE_UNICODE
9017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9018 #else
9019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9020 #endif
9021 }
9022 {
9023 if (temp1)
9024 delete arg1;
9025 }
9026 return resultobj;
9027 fail:
9028 {
9029 if (temp1)
9030 delete arg1;
9031 }
9032 return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9037 PyObject *resultobj;
9038 wxString *arg1 = 0 ;
9039 wxString result;
9040 bool temp1 = false ;
9041 PyObject * obj0 = 0 ;
9042 char *kwnames[] = {
9043 (char *) "url", NULL
9044 };
9045
9046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9047 {
9048 arg1 = wxString_in_helper(obj0);
9049 if (arg1 == NULL) SWIG_fail;
9050 temp1 = true;
9051 }
9052 {
9053 PyThreadState* __tstate = wxPyBeginAllowThreads();
9054 result = FileSystem_URLToFileName((wxString const &)*arg1);
9055
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 {
9060 #if wxUSE_UNICODE
9061 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9062 #else
9063 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9064 #endif
9065 }
9066 {
9067 if (temp1)
9068 delete arg1;
9069 }
9070 return resultobj;
9071 fail:
9072 {
9073 if (temp1)
9074 delete arg1;
9075 }
9076 return NULL;
9077 }
9078
9079
9080 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9081 PyObject *obj;
9082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9083 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9084 Py_INCREF(obj);
9085 return Py_BuildValue((char *)"");
9086 }
9087 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9088 PyObject *resultobj;
9089 wxInternetFSHandler *result;
9090 char *kwnames[] = {
9091 NULL
9092 };
9093
9094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9095 {
9096 PyThreadState* __tstate = wxPyBeginAllowThreads();
9097 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9098
9099 wxPyEndAllowThreads(__tstate);
9100 if (PyErr_Occurred()) SWIG_fail;
9101 }
9102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9103 return resultobj;
9104 fail:
9105 return NULL;
9106 }
9107
9108
9109 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9110 PyObject *resultobj;
9111 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9112 wxString *arg2 = 0 ;
9113 bool result;
9114 bool temp2 = false ;
9115 PyObject * obj0 = 0 ;
9116 PyObject * obj1 = 0 ;
9117 char *kwnames[] = {
9118 (char *) "self",(char *) "location", NULL
9119 };
9120
9121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9123 if (SWIG_arg_fail(1)) SWIG_fail;
9124 {
9125 arg2 = wxString_in_helper(obj1);
9126 if (arg2 == NULL) SWIG_fail;
9127 temp2 = true;
9128 }
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9132
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 {
9137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9138 }
9139 {
9140 if (temp2)
9141 delete arg2;
9142 }
9143 return resultobj;
9144 fail:
9145 {
9146 if (temp2)
9147 delete arg2;
9148 }
9149 return NULL;
9150 }
9151
9152
9153 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9154 PyObject *resultobj;
9155 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9156 wxFileSystem *arg2 = 0 ;
9157 wxString *arg3 = 0 ;
9158 wxFSFile *result;
9159 bool temp3 = false ;
9160 PyObject * obj0 = 0 ;
9161 PyObject * obj1 = 0 ;
9162 PyObject * obj2 = 0 ;
9163 char *kwnames[] = {
9164 (char *) "self",(char *) "fs",(char *) "location", NULL
9165 };
9166
9167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9169 if (SWIG_arg_fail(1)) SWIG_fail;
9170 {
9171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9172 if (SWIG_arg_fail(2)) SWIG_fail;
9173 if (arg2 == NULL) {
9174 SWIG_null_ref("wxFileSystem");
9175 }
9176 if (SWIG_arg_fail(2)) SWIG_fail;
9177 }
9178 {
9179 arg3 = wxString_in_helper(obj2);
9180 if (arg3 == NULL) SWIG_fail;
9181 temp3 = true;
9182 }
9183 {
9184 PyThreadState* __tstate = wxPyBeginAllowThreads();
9185 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9186
9187 wxPyEndAllowThreads(__tstate);
9188 if (PyErr_Occurred()) SWIG_fail;
9189 }
9190 {
9191 resultobj = wxPyMake_wxObject(result, 1);
9192 }
9193 {
9194 if (temp3)
9195 delete arg3;
9196 }
9197 return resultobj;
9198 fail:
9199 {
9200 if (temp3)
9201 delete arg3;
9202 }
9203 return NULL;
9204 }
9205
9206
9207 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9208 PyObject *obj;
9209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9210 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9211 Py_INCREF(obj);
9212 return Py_BuildValue((char *)"");
9213 }
9214 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9215 PyObject *resultobj;
9216 wxZipFSHandler *result;
9217 char *kwnames[] = {
9218 NULL
9219 };
9220
9221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9222 {
9223 PyThreadState* __tstate = wxPyBeginAllowThreads();
9224 result = (wxZipFSHandler *)new wxZipFSHandler();
9225
9226 wxPyEndAllowThreads(__tstate);
9227 if (PyErr_Occurred()) SWIG_fail;
9228 }
9229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9230 return resultobj;
9231 fail:
9232 return NULL;
9233 }
9234
9235
9236 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9237 PyObject *resultobj;
9238 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9239 wxString *arg2 = 0 ;
9240 bool result;
9241 bool temp2 = false ;
9242 PyObject * obj0 = 0 ;
9243 PyObject * obj1 = 0 ;
9244 char *kwnames[] = {
9245 (char *) "self",(char *) "location", NULL
9246 };
9247
9248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9250 if (SWIG_arg_fail(1)) SWIG_fail;
9251 {
9252 arg2 = wxString_in_helper(obj1);
9253 if (arg2 == NULL) SWIG_fail;
9254 temp2 = true;
9255 }
9256 {
9257 PyThreadState* __tstate = wxPyBeginAllowThreads();
9258 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9259
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 {
9264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9265 }
9266 {
9267 if (temp2)
9268 delete arg2;
9269 }
9270 return resultobj;
9271 fail:
9272 {
9273 if (temp2)
9274 delete arg2;
9275 }
9276 return NULL;
9277 }
9278
9279
9280 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9283 wxFileSystem *arg2 = 0 ;
9284 wxString *arg3 = 0 ;
9285 wxFSFile *result;
9286 bool temp3 = false ;
9287 PyObject * obj0 = 0 ;
9288 PyObject * obj1 = 0 ;
9289 PyObject * obj2 = 0 ;
9290 char *kwnames[] = {
9291 (char *) "self",(char *) "fs",(char *) "location", NULL
9292 };
9293
9294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9296 if (SWIG_arg_fail(1)) SWIG_fail;
9297 {
9298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9299 if (SWIG_arg_fail(2)) SWIG_fail;
9300 if (arg2 == NULL) {
9301 SWIG_null_ref("wxFileSystem");
9302 }
9303 if (SWIG_arg_fail(2)) SWIG_fail;
9304 }
9305 {
9306 arg3 = wxString_in_helper(obj2);
9307 if (arg3 == NULL) SWIG_fail;
9308 temp3 = true;
9309 }
9310 {
9311 PyThreadState* __tstate = wxPyBeginAllowThreads();
9312 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9313
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 {
9318 resultobj = wxPyMake_wxObject(result, 1);
9319 }
9320 {
9321 if (temp3)
9322 delete arg3;
9323 }
9324 return resultobj;
9325 fail:
9326 {
9327 if (temp3)
9328 delete arg3;
9329 }
9330 return NULL;
9331 }
9332
9333
9334 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9335 PyObject *resultobj;
9336 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9337 wxString *arg2 = 0 ;
9338 int arg3 = (int) 0 ;
9339 wxString result;
9340 bool temp2 = false ;
9341 PyObject * obj0 = 0 ;
9342 PyObject * obj1 = 0 ;
9343 PyObject * obj2 = 0 ;
9344 char *kwnames[] = {
9345 (char *) "self",(char *) "spec",(char *) "flags", NULL
9346 };
9347
9348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9350 if (SWIG_arg_fail(1)) SWIG_fail;
9351 {
9352 arg2 = wxString_in_helper(obj1);
9353 if (arg2 == NULL) SWIG_fail;
9354 temp2 = true;
9355 }
9356 if (obj2) {
9357 {
9358 arg3 = (int)(SWIG_As_int(obj2));
9359 if (SWIG_arg_fail(3)) SWIG_fail;
9360 }
9361 }
9362 {
9363 PyThreadState* __tstate = wxPyBeginAllowThreads();
9364 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9365
9366 wxPyEndAllowThreads(__tstate);
9367 if (PyErr_Occurred()) SWIG_fail;
9368 }
9369 {
9370 #if wxUSE_UNICODE
9371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9372 #else
9373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9374 #endif
9375 }
9376 {
9377 if (temp2)
9378 delete arg2;
9379 }
9380 return resultobj;
9381 fail:
9382 {
9383 if (temp2)
9384 delete arg2;
9385 }
9386 return NULL;
9387 }
9388
9389
9390 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9391 PyObject *resultobj;
9392 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9393 wxString result;
9394 PyObject * obj0 = 0 ;
9395 char *kwnames[] = {
9396 (char *) "self", NULL
9397 };
9398
9399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9401 if (SWIG_arg_fail(1)) SWIG_fail;
9402 {
9403 PyThreadState* __tstate = wxPyBeginAllowThreads();
9404 result = (arg1)->FindNext();
9405
9406 wxPyEndAllowThreads(__tstate);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 {
9410 #if wxUSE_UNICODE
9411 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9412 #else
9413 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9414 #endif
9415 }
9416 return resultobj;
9417 fail:
9418 return NULL;
9419 }
9420
9421
9422 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9423 PyObject *obj;
9424 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9425 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9426 Py_INCREF(obj);
9427 return Py_BuildValue((char *)"");
9428 }
9429 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj;
9431 wxString *arg1 = 0 ;
9432 wxImage *arg2 = 0 ;
9433 long arg3 ;
9434 bool temp1 = false ;
9435 PyObject * obj0 = 0 ;
9436 PyObject * obj1 = 0 ;
9437 PyObject * obj2 = 0 ;
9438 char *kwnames[] = {
9439 (char *) "filename",(char *) "image",(char *) "type", NULL
9440 };
9441
9442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9443 {
9444 arg1 = wxString_in_helper(obj0);
9445 if (arg1 == NULL) SWIG_fail;
9446 temp1 = true;
9447 }
9448 {
9449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9450 if (SWIG_arg_fail(2)) SWIG_fail;
9451 if (arg2 == NULL) {
9452 SWIG_null_ref("wxImage");
9453 }
9454 if (SWIG_arg_fail(2)) SWIG_fail;
9455 }
9456 {
9457 arg3 = (long)(SWIG_As_long(obj2));
9458 if (SWIG_arg_fail(3)) SWIG_fail;
9459 }
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9463
9464 wxPyEndAllowThreads(__tstate);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 Py_INCREF(Py_None); resultobj = Py_None;
9468 {
9469 if (temp1)
9470 delete arg1;
9471 }
9472 return resultobj;
9473 fail:
9474 {
9475 if (temp1)
9476 delete arg1;
9477 }
9478 return NULL;
9479 }
9480
9481
9482 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj;
9484 wxString *arg1 = 0 ;
9485 wxBitmap *arg2 = 0 ;
9486 long arg3 ;
9487 bool temp1 = false ;
9488 PyObject * obj0 = 0 ;
9489 PyObject * obj1 = 0 ;
9490 PyObject * obj2 = 0 ;
9491 char *kwnames[] = {
9492 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9493 };
9494
9495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9496 {
9497 arg1 = wxString_in_helper(obj0);
9498 if (arg1 == NULL) SWIG_fail;
9499 temp1 = true;
9500 }
9501 {
9502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9503 if (SWIG_arg_fail(2)) SWIG_fail;
9504 if (arg2 == NULL) {
9505 SWIG_null_ref("wxBitmap");
9506 }
9507 if (SWIG_arg_fail(2)) SWIG_fail;
9508 }
9509 {
9510 arg3 = (long)(SWIG_As_long(obj2));
9511 if (SWIG_arg_fail(3)) SWIG_fail;
9512 }
9513 {
9514 PyThreadState* __tstate = wxPyBeginAllowThreads();
9515 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9516
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 Py_INCREF(Py_None); resultobj = Py_None;
9521 {
9522 if (temp1)
9523 delete arg1;
9524 }
9525 return resultobj;
9526 fail:
9527 {
9528 if (temp1)
9529 delete arg1;
9530 }
9531 return NULL;
9532 }
9533
9534
9535 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj;
9537 wxString *arg1 = 0 ;
9538 PyObject *arg2 = (PyObject *) 0 ;
9539 bool temp1 = false ;
9540 PyObject * obj0 = 0 ;
9541 PyObject * obj1 = 0 ;
9542 char *kwnames[] = {
9543 (char *) "filename",(char *) "data", NULL
9544 };
9545
9546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9547 {
9548 arg1 = wxString_in_helper(obj0);
9549 if (arg1 == NULL) SWIG_fail;
9550 temp1 = true;
9551 }
9552 arg2 = obj1;
9553 {
9554 PyThreadState* __tstate = wxPyBeginAllowThreads();
9555 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9556
9557 wxPyEndAllowThreads(__tstate);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 Py_INCREF(Py_None); resultobj = Py_None;
9561 {
9562 if (temp1)
9563 delete arg1;
9564 }
9565 return resultobj;
9566 fail:
9567 {
9568 if (temp1)
9569 delete arg1;
9570 }
9571 return NULL;
9572 }
9573
9574
9575 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9576 PyObject *resultobj;
9577 wxMemoryFSHandler *result;
9578 char *kwnames[] = {
9579 NULL
9580 };
9581
9582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9586
9587 wxPyEndAllowThreads(__tstate);
9588 if (PyErr_Occurred()) SWIG_fail;
9589 }
9590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9591 return resultobj;
9592 fail:
9593 return NULL;
9594 }
9595
9596
9597 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9598 PyObject *resultobj;
9599 wxString *arg1 = 0 ;
9600 bool temp1 = false ;
9601 PyObject * obj0 = 0 ;
9602 char *kwnames[] = {
9603 (char *) "filename", NULL
9604 };
9605
9606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9607 {
9608 arg1 = wxString_in_helper(obj0);
9609 if (arg1 == NULL) SWIG_fail;
9610 temp1 = true;
9611 }
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9615
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 Py_INCREF(Py_None); resultobj = Py_None;
9620 {
9621 if (temp1)
9622 delete arg1;
9623 }
9624 return resultobj;
9625 fail:
9626 {
9627 if (temp1)
9628 delete arg1;
9629 }
9630 return NULL;
9631 }
9632
9633
9634 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj;
9636 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9637 wxString *arg2 = 0 ;
9638 bool result;
9639 bool temp2 = false ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char *kwnames[] = {
9643 (char *) "self",(char *) "location", NULL
9644 };
9645
9646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9648 if (SWIG_arg_fail(1)) SWIG_fail;
9649 {
9650 arg2 = wxString_in_helper(obj1);
9651 if (arg2 == NULL) SWIG_fail;
9652 temp2 = true;
9653 }
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9657
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 {
9662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9663 }
9664 {
9665 if (temp2)
9666 delete arg2;
9667 }
9668 return resultobj;
9669 fail:
9670 {
9671 if (temp2)
9672 delete arg2;
9673 }
9674 return NULL;
9675 }
9676
9677
9678 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9679 PyObject *resultobj;
9680 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9681 wxFileSystem *arg2 = 0 ;
9682 wxString *arg3 = 0 ;
9683 wxFSFile *result;
9684 bool temp3 = false ;
9685 PyObject * obj0 = 0 ;
9686 PyObject * obj1 = 0 ;
9687 PyObject * obj2 = 0 ;
9688 char *kwnames[] = {
9689 (char *) "self",(char *) "fs",(char *) "location", NULL
9690 };
9691
9692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9694 if (SWIG_arg_fail(1)) SWIG_fail;
9695 {
9696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9697 if (SWIG_arg_fail(2)) SWIG_fail;
9698 if (arg2 == NULL) {
9699 SWIG_null_ref("wxFileSystem");
9700 }
9701 if (SWIG_arg_fail(2)) SWIG_fail;
9702 }
9703 {
9704 arg3 = wxString_in_helper(obj2);
9705 if (arg3 == NULL) SWIG_fail;
9706 temp3 = true;
9707 }
9708 {
9709 PyThreadState* __tstate = wxPyBeginAllowThreads();
9710 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9711
9712 wxPyEndAllowThreads(__tstate);
9713 if (PyErr_Occurred()) SWIG_fail;
9714 }
9715 {
9716 resultobj = wxPyMake_wxObject(result, 1);
9717 }
9718 {
9719 if (temp3)
9720 delete arg3;
9721 }
9722 return resultobj;
9723 fail:
9724 {
9725 if (temp3)
9726 delete arg3;
9727 }
9728 return NULL;
9729 }
9730
9731
9732 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9733 PyObject *resultobj;
9734 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9735 wxString *arg2 = 0 ;
9736 int arg3 = (int) 0 ;
9737 wxString result;
9738 bool temp2 = false ;
9739 PyObject * obj0 = 0 ;
9740 PyObject * obj1 = 0 ;
9741 PyObject * obj2 = 0 ;
9742 char *kwnames[] = {
9743 (char *) "self",(char *) "spec",(char *) "flags", NULL
9744 };
9745
9746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9748 if (SWIG_arg_fail(1)) SWIG_fail;
9749 {
9750 arg2 = wxString_in_helper(obj1);
9751 if (arg2 == NULL) SWIG_fail;
9752 temp2 = true;
9753 }
9754 if (obj2) {
9755 {
9756 arg3 = (int)(SWIG_As_int(obj2));
9757 if (SWIG_arg_fail(3)) SWIG_fail;
9758 }
9759 }
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9763
9764 wxPyEndAllowThreads(__tstate);
9765 if (PyErr_Occurred()) SWIG_fail;
9766 }
9767 {
9768 #if wxUSE_UNICODE
9769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9770 #else
9771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9772 #endif
9773 }
9774 {
9775 if (temp2)
9776 delete arg2;
9777 }
9778 return resultobj;
9779 fail:
9780 {
9781 if (temp2)
9782 delete arg2;
9783 }
9784 return NULL;
9785 }
9786
9787
9788 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9789 PyObject *resultobj;
9790 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9791 wxString result;
9792 PyObject * obj0 = 0 ;
9793 char *kwnames[] = {
9794 (char *) "self", NULL
9795 };
9796
9797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9799 if (SWIG_arg_fail(1)) SWIG_fail;
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 result = (arg1)->FindNext();
9803
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 {
9808 #if wxUSE_UNICODE
9809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9810 #else
9811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9812 #endif
9813 }
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9821 PyObject *obj;
9822 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9823 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9824 Py_INCREF(obj);
9825 return Py_BuildValue((char *)"");
9826 }
9827 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9828 PyObject *resultobj;
9829 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9830 wxString result;
9831 PyObject * obj0 = 0 ;
9832 char *kwnames[] = {
9833 (char *) "self", NULL
9834 };
9835
9836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9838 if (SWIG_arg_fail(1)) SWIG_fail;
9839 {
9840 PyThreadState* __tstate = wxPyBeginAllowThreads();
9841 result = (arg1)->GetName();
9842
9843 wxPyEndAllowThreads(__tstate);
9844 if (PyErr_Occurred()) SWIG_fail;
9845 }
9846 {
9847 #if wxUSE_UNICODE
9848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9849 #else
9850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9851 #endif
9852 }
9853 return resultobj;
9854 fail:
9855 return NULL;
9856 }
9857
9858
9859 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9860 PyObject *resultobj;
9861 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9862 wxString result;
9863 PyObject * obj0 = 0 ;
9864 char *kwnames[] = {
9865 (char *) "self", NULL
9866 };
9867
9868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9870 if (SWIG_arg_fail(1)) SWIG_fail;
9871 {
9872 PyThreadState* __tstate = wxPyBeginAllowThreads();
9873 result = (arg1)->GetExtension();
9874
9875 wxPyEndAllowThreads(__tstate);
9876 if (PyErr_Occurred()) SWIG_fail;
9877 }
9878 {
9879 #if wxUSE_UNICODE
9880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9881 #else
9882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9883 #endif
9884 }
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj;
9893 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9894 long result;
9895 PyObject * obj0 = 0 ;
9896 char *kwnames[] = {
9897 (char *) "self", NULL
9898 };
9899
9900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9902 if (SWIG_arg_fail(1)) SWIG_fail;
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 result = (long)(arg1)->GetType();
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 {
9911 resultobj = SWIG_From_long((long)(result));
9912 }
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj;
9921 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9922 wxString result;
9923 PyObject * obj0 = 0 ;
9924 char *kwnames[] = {
9925 (char *) "self", NULL
9926 };
9927
9928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(1)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (arg1)->GetMimeType();
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 {
9939 #if wxUSE_UNICODE
9940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9941 #else
9942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9943 #endif
9944 }
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj;
9953 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9954 wxString *arg2 = 0 ;
9955 bool result;
9956 bool temp2 = false ;
9957 PyObject * obj0 = 0 ;
9958 PyObject * obj1 = 0 ;
9959 char *kwnames[] = {
9960 (char *) "self",(char *) "name", NULL
9961 };
9962
9963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9965 if (SWIG_arg_fail(1)) SWIG_fail;
9966 {
9967 arg2 = wxString_in_helper(obj1);
9968 if (arg2 == NULL) SWIG_fail;
9969 temp2 = true;
9970 }
9971 {
9972 PyThreadState* __tstate = wxPyBeginAllowThreads();
9973 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9974
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 {
9979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9980 }
9981 {
9982 if (temp2)
9983 delete arg2;
9984 }
9985 return resultobj;
9986 fail:
9987 {
9988 if (temp2)
9989 delete arg2;
9990 }
9991 return NULL;
9992 }
9993
9994
9995 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9996 PyObject *resultobj;
9997 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9998 wxString *arg2 = 0 ;
9999 bool temp2 = false ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 char *kwnames[] = {
10003 (char *) "self",(char *) "name", NULL
10004 };
10005
10006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10008 if (SWIG_arg_fail(1)) SWIG_fail;
10009 {
10010 arg2 = wxString_in_helper(obj1);
10011 if (arg2 == NULL) SWIG_fail;
10012 temp2 = true;
10013 }
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 (arg1)->SetName((wxString const &)*arg2);
10017
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 Py_INCREF(Py_None); resultobj = Py_None;
10022 {
10023 if (temp2)
10024 delete arg2;
10025 }
10026 return resultobj;
10027 fail:
10028 {
10029 if (temp2)
10030 delete arg2;
10031 }
10032 return NULL;
10033 }
10034
10035
10036 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj;
10038 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10039 wxString *arg2 = 0 ;
10040 bool temp2 = false ;
10041 PyObject * obj0 = 0 ;
10042 PyObject * obj1 = 0 ;
10043 char *kwnames[] = {
10044 (char *) "self",(char *) "extension", NULL
10045 };
10046
10047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10049 if (SWIG_arg_fail(1)) SWIG_fail;
10050 {
10051 arg2 = wxString_in_helper(obj1);
10052 if (arg2 == NULL) SWIG_fail;
10053 temp2 = true;
10054 }
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 (arg1)->SetExtension((wxString const &)*arg2);
10058
10059 wxPyEndAllowThreads(__tstate);
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 Py_INCREF(Py_None); resultobj = Py_None;
10063 {
10064 if (temp2)
10065 delete arg2;
10066 }
10067 return resultobj;
10068 fail:
10069 {
10070 if (temp2)
10071 delete arg2;
10072 }
10073 return NULL;
10074 }
10075
10076
10077 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10078 PyObject *resultobj;
10079 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10080 long arg2 ;
10081 PyObject * obj0 = 0 ;
10082 PyObject * obj1 = 0 ;
10083 char *kwnames[] = {
10084 (char *) "self",(char *) "type", NULL
10085 };
10086
10087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10089 if (SWIG_arg_fail(1)) SWIG_fail;
10090 {
10091 arg2 = (long)(SWIG_As_long(obj1));
10092 if (SWIG_arg_fail(2)) SWIG_fail;
10093 }
10094 {
10095 PyThreadState* __tstate = wxPyBeginAllowThreads();
10096 (arg1)->SetType(arg2);
10097
10098 wxPyEndAllowThreads(__tstate);
10099 if (PyErr_Occurred()) SWIG_fail;
10100 }
10101 Py_INCREF(Py_None); resultobj = Py_None;
10102 return resultobj;
10103 fail:
10104 return NULL;
10105 }
10106
10107
10108 static PyObject *_wrap_ImageHandler_SetMimeType(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 *) "mimetype", NULL
10117 };
10118
10119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",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)->SetMimeType((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 * ImageHandler_swigregister(PyObject *, PyObject *args) {
10150 PyObject *obj;
10151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10152 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10153 Py_INCREF(obj);
10154 return Py_BuildValue((char *)"");
10155 }
10156 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10157 PyObject *resultobj;
10158 wxImageHistogram *result;
10159 char *kwnames[] = {
10160 NULL
10161 };
10162
10163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10164 {
10165 PyThreadState* __tstate = wxPyBeginAllowThreads();
10166 result = (wxImageHistogram *)new wxImageHistogram();
10167
10168 wxPyEndAllowThreads(__tstate);
10169 if (PyErr_Occurred()) SWIG_fail;
10170 }
10171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj;
10180 unsigned char arg1 ;
10181 unsigned char arg2 ;
10182 unsigned char arg3 ;
10183 unsigned long result;
10184 PyObject * obj0 = 0 ;
10185 PyObject * obj1 = 0 ;
10186 PyObject * obj2 = 0 ;
10187 char *kwnames[] = {
10188 (char *) "r",(char *) "g",(char *) "b", NULL
10189 };
10190
10191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10192 {
10193 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10194 if (SWIG_arg_fail(1)) SWIG_fail;
10195 }
10196 {
10197 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10198 if (SWIG_arg_fail(2)) SWIG_fail;
10199 }
10200 {
10201 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10202 if (SWIG_arg_fail(3)) SWIG_fail;
10203 }
10204 {
10205 PyThreadState* __tstate = wxPyBeginAllowThreads();
10206 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10207
10208 wxPyEndAllowThreads(__tstate);
10209 if (PyErr_Occurred()) SWIG_fail;
10210 }
10211 {
10212 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10213 }
10214 return resultobj;
10215 fail:
10216 return NULL;
10217 }
10218
10219
10220 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10221 PyObject *resultobj;
10222 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10223 unsigned char *arg2 = (unsigned char *) 0 ;
10224 unsigned char *arg3 = (unsigned char *) 0 ;
10225 unsigned char *arg4 = (unsigned char *) 0 ;
10226 unsigned char arg5 = (unsigned char) 1 ;
10227 unsigned char arg6 = (unsigned char) 0 ;
10228 unsigned char arg7 = (unsigned char) 0 ;
10229 bool result;
10230 unsigned char temp2 ;
10231 int res2 = 0 ;
10232 unsigned char temp3 ;
10233 int res3 = 0 ;
10234 unsigned char temp4 ;
10235 int res4 = 0 ;
10236 PyObject * obj0 = 0 ;
10237 PyObject * obj1 = 0 ;
10238 PyObject * obj2 = 0 ;
10239 PyObject * obj3 = 0 ;
10240 char *kwnames[] = {
10241 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10242 };
10243
10244 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10245 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10246 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10249 if (SWIG_arg_fail(1)) SWIG_fail;
10250 if (obj1) {
10251 {
10252 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10253 if (SWIG_arg_fail(5)) SWIG_fail;
10254 }
10255 }
10256 if (obj2) {
10257 {
10258 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10259 if (SWIG_arg_fail(6)) SWIG_fail;
10260 }
10261 }
10262 if (obj3) {
10263 {
10264 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10265 if (SWIG_arg_fail(7)) SWIG_fail;
10266 }
10267 }
10268 {
10269 PyThreadState* __tstate = wxPyBeginAllowThreads();
10270 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10271
10272 wxPyEndAllowThreads(__tstate);
10273 if (PyErr_Occurred()) SWIG_fail;
10274 }
10275 {
10276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10277 }
10278 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10279 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10280 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10281 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10282 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10283 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10284 return resultobj;
10285 fail:
10286 return NULL;
10287 }
10288
10289
10290 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10291 PyObject *obj;
10292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10293 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10294 Py_INCREF(obj);
10295 return Py_BuildValue((char *)"");
10296 }
10297 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10298 PyObject *resultobj;
10299 wxString *arg1 = 0 ;
10300 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10301 int arg3 = (int) -1 ;
10302 wxImage *result;
10303 bool temp1 = false ;
10304 PyObject * obj0 = 0 ;
10305 PyObject * obj1 = 0 ;
10306 PyObject * obj2 = 0 ;
10307 char *kwnames[] = {
10308 (char *) "name",(char *) "type",(char *) "index", NULL
10309 };
10310
10311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10312 {
10313 arg1 = wxString_in_helper(obj0);
10314 if (arg1 == NULL) SWIG_fail;
10315 temp1 = true;
10316 }
10317 if (obj1) {
10318 {
10319 arg2 = (long)(SWIG_As_long(obj1));
10320 if (SWIG_arg_fail(2)) SWIG_fail;
10321 }
10322 }
10323 if (obj2) {
10324 {
10325 arg3 = (int)(SWIG_As_int(obj2));
10326 if (SWIG_arg_fail(3)) SWIG_fail;
10327 }
10328 }
10329 {
10330 PyThreadState* __tstate = wxPyBeginAllowThreads();
10331 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10332
10333 wxPyEndAllowThreads(__tstate);
10334 if (PyErr_Occurred()) SWIG_fail;
10335 }
10336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10337 {
10338 if (temp1)
10339 delete arg1;
10340 }
10341 return resultobj;
10342 fail:
10343 {
10344 if (temp1)
10345 delete arg1;
10346 }
10347 return NULL;
10348 }
10349
10350
10351 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10352 PyObject *resultobj;
10353 wxImage *arg1 = (wxImage *) 0 ;
10354 PyObject * obj0 = 0 ;
10355 char *kwnames[] = {
10356 (char *) "self", NULL
10357 };
10358
10359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10361 if (SWIG_arg_fail(1)) SWIG_fail;
10362 {
10363 PyThreadState* __tstate = wxPyBeginAllowThreads();
10364 delete arg1;
10365
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 Py_INCREF(Py_None); resultobj = Py_None;
10370 return resultobj;
10371 fail:
10372 return NULL;
10373 }
10374
10375
10376 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10377 PyObject *resultobj;
10378 wxString *arg1 = 0 ;
10379 wxString *arg2 = 0 ;
10380 int arg3 = (int) -1 ;
10381 wxImage *result;
10382 bool temp1 = false ;
10383 bool temp2 = false ;
10384 PyObject * obj0 = 0 ;
10385 PyObject * obj1 = 0 ;
10386 PyObject * obj2 = 0 ;
10387 char *kwnames[] = {
10388 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10389 };
10390
10391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10392 {
10393 arg1 = wxString_in_helper(obj0);
10394 if (arg1 == NULL) SWIG_fail;
10395 temp1 = true;
10396 }
10397 {
10398 arg2 = wxString_in_helper(obj1);
10399 if (arg2 == NULL) SWIG_fail;
10400 temp2 = true;
10401 }
10402 if (obj2) {
10403 {
10404 arg3 = (int)(SWIG_As_int(obj2));
10405 if (SWIG_arg_fail(3)) SWIG_fail;
10406 }
10407 }
10408 {
10409 PyThreadState* __tstate = wxPyBeginAllowThreads();
10410 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10411
10412 wxPyEndAllowThreads(__tstate);
10413 if (PyErr_Occurred()) SWIG_fail;
10414 }
10415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10416 {
10417 if (temp1)
10418 delete arg1;
10419 }
10420 {
10421 if (temp2)
10422 delete arg2;
10423 }
10424 return resultobj;
10425 fail:
10426 {
10427 if (temp1)
10428 delete arg1;
10429 }
10430 {
10431 if (temp2)
10432 delete arg2;
10433 }
10434 return NULL;
10435 }
10436
10437
10438 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10439 PyObject *resultobj;
10440 wxInputStream *arg1 = 0 ;
10441 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10442 int arg3 = (int) -1 ;
10443 wxImage *result;
10444 wxPyInputStream *temp1 ;
10445 bool created1 ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 PyObject * obj2 = 0 ;
10449 char *kwnames[] = {
10450 (char *) "stream",(char *) "type",(char *) "index", NULL
10451 };
10452
10453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10454 {
10455 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10456 arg1 = temp1->m_wxis;
10457 created1 = false;
10458 } else {
10459 PyErr_Clear(); // clear the failure of the wxPyConvert above
10460 arg1 = wxPyCBInputStream_create(obj0, false);
10461 if (arg1 == NULL) {
10462 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10463 SWIG_fail;
10464 }
10465 created1 = true;
10466 }
10467 }
10468 if (obj1) {
10469 {
10470 arg2 = (long)(SWIG_As_long(obj1));
10471 if (SWIG_arg_fail(2)) SWIG_fail;
10472 }
10473 }
10474 if (obj2) {
10475 {
10476 arg3 = (int)(SWIG_As_int(obj2));
10477 if (SWIG_arg_fail(3)) SWIG_fail;
10478 }
10479 }
10480 {
10481 PyThreadState* __tstate = wxPyBeginAllowThreads();
10482 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10483
10484 wxPyEndAllowThreads(__tstate);
10485 if (PyErr_Occurred()) SWIG_fail;
10486 }
10487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10488 {
10489 if (created1) delete arg1;
10490 }
10491 return resultobj;
10492 fail:
10493 {
10494 if (created1) delete arg1;
10495 }
10496 return NULL;
10497 }
10498
10499
10500 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10501 PyObject *resultobj;
10502 wxInputStream *arg1 = 0 ;
10503 wxString *arg2 = 0 ;
10504 int arg3 = (int) -1 ;
10505 wxImage *result;
10506 wxPyInputStream *temp1 ;
10507 bool created1 ;
10508 bool temp2 = false ;
10509 PyObject * obj0 = 0 ;
10510 PyObject * obj1 = 0 ;
10511 PyObject * obj2 = 0 ;
10512 char *kwnames[] = {
10513 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10514 };
10515
10516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10517 {
10518 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10519 arg1 = temp1->m_wxis;
10520 created1 = false;
10521 } else {
10522 PyErr_Clear(); // clear the failure of the wxPyConvert above
10523 arg1 = wxPyCBInputStream_create(obj0, false);
10524 if (arg1 == NULL) {
10525 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10526 SWIG_fail;
10527 }
10528 created1 = true;
10529 }
10530 }
10531 {
10532 arg2 = wxString_in_helper(obj1);
10533 if (arg2 == NULL) SWIG_fail;
10534 temp2 = true;
10535 }
10536 if (obj2) {
10537 {
10538 arg3 = (int)(SWIG_As_int(obj2));
10539 if (SWIG_arg_fail(3)) SWIG_fail;
10540 }
10541 }
10542 {
10543 PyThreadState* __tstate = wxPyBeginAllowThreads();
10544 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10545
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10550 {
10551 if (created1) delete arg1;
10552 }
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (created1) delete arg1;
10561 }
10562 {
10563 if (temp2)
10564 delete arg2;
10565 }
10566 return NULL;
10567 }
10568
10569
10570 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10571 PyObject *resultobj;
10572 int arg1 = (int) 0 ;
10573 int arg2 = (int) 0 ;
10574 bool arg3 = (bool) true ;
10575 wxImage *result;
10576 PyObject * obj0 = 0 ;
10577 PyObject * obj1 = 0 ;
10578 PyObject * obj2 = 0 ;
10579 char *kwnames[] = {
10580 (char *) "width",(char *) "height",(char *) "clear", NULL
10581 };
10582
10583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10584 if (obj0) {
10585 {
10586 arg1 = (int)(SWIG_As_int(obj0));
10587 if (SWIG_arg_fail(1)) SWIG_fail;
10588 }
10589 }
10590 if (obj1) {
10591 {
10592 arg2 = (int)(SWIG_As_int(obj1));
10593 if (SWIG_arg_fail(2)) SWIG_fail;
10594 }
10595 }
10596 if (obj2) {
10597 {
10598 arg3 = (bool)(SWIG_As_bool(obj2));
10599 if (SWIG_arg_fail(3)) SWIG_fail;
10600 }
10601 }
10602 {
10603 PyThreadState* __tstate = wxPyBeginAllowThreads();
10604 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10605
10606 wxPyEndAllowThreads(__tstate);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10610 return resultobj;
10611 fail:
10612 return NULL;
10613 }
10614
10615
10616 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10617 PyObject *resultobj;
10618 wxBitmap *arg1 = 0 ;
10619 wxImage *result;
10620 PyObject * obj0 = 0 ;
10621 char *kwnames[] = {
10622 (char *) "bitmap", NULL
10623 };
10624
10625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10626 {
10627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10628 if (SWIG_arg_fail(1)) SWIG_fail;
10629 if (arg1 == NULL) {
10630 SWIG_null_ref("wxBitmap");
10631 }
10632 if (SWIG_arg_fail(1)) SWIG_fail;
10633 }
10634 {
10635 if (!wxPyCheckForApp()) SWIG_fail;
10636 PyThreadState* __tstate = wxPyBeginAllowThreads();
10637 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10638
10639 wxPyEndAllowThreads(__tstate);
10640 if (PyErr_Occurred()) SWIG_fail;
10641 }
10642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10643 return resultobj;
10644 fail:
10645 return NULL;
10646 }
10647
10648
10649 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10650 PyObject *resultobj;
10651 int arg1 ;
10652 int arg2 ;
10653 unsigned char *arg3 = (unsigned char *) 0 ;
10654 wxImage *result;
10655 PyObject * obj0 = 0 ;
10656 PyObject * obj1 = 0 ;
10657 PyObject * obj2 = 0 ;
10658 char *kwnames[] = {
10659 (char *) "width",(char *) "height",(char *) "data", NULL
10660 };
10661
10662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10663 {
10664 arg1 = (int)(SWIG_As_int(obj0));
10665 if (SWIG_arg_fail(1)) SWIG_fail;
10666 }
10667 {
10668 arg2 = (int)(SWIG_As_int(obj1));
10669 if (SWIG_arg_fail(2)) SWIG_fail;
10670 }
10671 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10672 if (SWIG_arg_fail(3)) SWIG_fail;
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10676
10677 wxPyEndAllowThreads(__tstate);
10678 if (PyErr_Occurred()) SWIG_fail;
10679 }
10680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10681 return resultobj;
10682 fail:
10683 return NULL;
10684 }
10685
10686
10687 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10688 PyObject *resultobj;
10689 int arg1 ;
10690 int arg2 ;
10691 unsigned char *arg3 = (unsigned char *) 0 ;
10692 unsigned char *arg4 = (unsigned char *) 0 ;
10693 wxImage *result;
10694 PyObject * obj0 = 0 ;
10695 PyObject * obj1 = 0 ;
10696 PyObject * obj2 = 0 ;
10697 PyObject * obj3 = 0 ;
10698 char *kwnames[] = {
10699 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10700 };
10701
10702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10703 {
10704 arg1 = (int)(SWIG_As_int(obj0));
10705 if (SWIG_arg_fail(1)) SWIG_fail;
10706 }
10707 {
10708 arg2 = (int)(SWIG_As_int(obj1));
10709 if (SWIG_arg_fail(2)) SWIG_fail;
10710 }
10711 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10712 if (SWIG_arg_fail(3)) SWIG_fail;
10713 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10714 if (SWIG_arg_fail(4)) SWIG_fail;
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10718
10719 wxPyEndAllowThreads(__tstate);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj;
10731 wxImage *arg1 = (wxImage *) 0 ;
10732 int arg2 ;
10733 int arg3 ;
10734 PyObject * obj0 = 0 ;
10735 PyObject * obj1 = 0 ;
10736 PyObject * obj2 = 0 ;
10737 char *kwnames[] = {
10738 (char *) "self",(char *) "width",(char *) "height", NULL
10739 };
10740
10741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10743 if (SWIG_arg_fail(1)) SWIG_fail;
10744 {
10745 arg2 = (int)(SWIG_As_int(obj1));
10746 if (SWIG_arg_fail(2)) SWIG_fail;
10747 }
10748 {
10749 arg3 = (int)(SWIG_As_int(obj2));
10750 if (SWIG_arg_fail(3)) SWIG_fail;
10751 }
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 (arg1)->Create(arg2,arg3);
10755
10756 wxPyEndAllowThreads(__tstate);
10757 if (PyErr_Occurred()) SWIG_fail;
10758 }
10759 Py_INCREF(Py_None); resultobj = Py_None;
10760 return resultobj;
10761 fail:
10762 return NULL;
10763 }
10764
10765
10766 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10767 PyObject *resultobj;
10768 wxImage *arg1 = (wxImage *) 0 ;
10769 PyObject * obj0 = 0 ;
10770 char *kwnames[] = {
10771 (char *) "self", NULL
10772 };
10773
10774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10776 if (SWIG_arg_fail(1)) SWIG_fail;
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 (arg1)->Destroy();
10780
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 Py_INCREF(Py_None); resultobj = Py_None;
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj;
10793 wxImage *arg1 = (wxImage *) 0 ;
10794 int arg2 ;
10795 int arg3 ;
10796 SwigValueWrapper<wxImage > result;
10797 PyObject * obj0 = 0 ;
10798 PyObject * obj1 = 0 ;
10799 PyObject * obj2 = 0 ;
10800 char *kwnames[] = {
10801 (char *) "self",(char *) "width",(char *) "height", NULL
10802 };
10803
10804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10806 if (SWIG_arg_fail(1)) SWIG_fail;
10807 {
10808 arg2 = (int)(SWIG_As_int(obj1));
10809 if (SWIG_arg_fail(2)) SWIG_fail;
10810 }
10811 {
10812 arg3 = (int)(SWIG_As_int(obj2));
10813 if (SWIG_arg_fail(3)) SWIG_fail;
10814 }
10815 {
10816 PyThreadState* __tstate = wxPyBeginAllowThreads();
10817 result = (arg1)->Scale(arg2,arg3);
10818
10819 wxPyEndAllowThreads(__tstate);
10820 if (PyErr_Occurred()) SWIG_fail;
10821 }
10822 {
10823 wxImage * resultptr;
10824 resultptr = new wxImage((wxImage &)(result));
10825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10826 }
10827 return resultobj;
10828 fail:
10829 return NULL;
10830 }
10831
10832
10833 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10834 PyObject *resultobj;
10835 wxImage *arg1 = (wxImage *) 0 ;
10836 int arg2 ;
10837 int arg3 ;
10838 SwigValueWrapper<wxImage > result;
10839 PyObject * obj0 = 0 ;
10840 PyObject * obj1 = 0 ;
10841 PyObject * obj2 = 0 ;
10842 char *kwnames[] = {
10843 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10844 };
10845
10846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10848 if (SWIG_arg_fail(1)) SWIG_fail;
10849 {
10850 arg2 = (int)(SWIG_As_int(obj1));
10851 if (SWIG_arg_fail(2)) SWIG_fail;
10852 }
10853 {
10854 arg3 = (int)(SWIG_As_int(obj2));
10855 if (SWIG_arg_fail(3)) SWIG_fail;
10856 }
10857 {
10858 PyThreadState* __tstate = wxPyBeginAllowThreads();
10859 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10860
10861 wxPyEndAllowThreads(__tstate);
10862 if (PyErr_Occurred()) SWIG_fail;
10863 }
10864 {
10865 wxImage * resultptr;
10866 resultptr = new wxImage((wxImage &)(result));
10867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10868 }
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj;
10877 wxImage *arg1 = (wxImage *) 0 ;
10878 int arg2 ;
10879 int arg3 ;
10880 wxImage *result;
10881 PyObject * obj0 = 0 ;
10882 PyObject * obj1 = 0 ;
10883 PyObject * obj2 = 0 ;
10884 char *kwnames[] = {
10885 (char *) "self",(char *) "width",(char *) "height", NULL
10886 };
10887
10888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10890 if (SWIG_arg_fail(1)) SWIG_fail;
10891 {
10892 arg2 = (int)(SWIG_As_int(obj1));
10893 if (SWIG_arg_fail(2)) SWIG_fail;
10894 }
10895 {
10896 arg3 = (int)(SWIG_As_int(obj2));
10897 if (SWIG_arg_fail(3)) SWIG_fail;
10898 }
10899 {
10900 PyThreadState* __tstate = wxPyBeginAllowThreads();
10901 {
10902 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10903 result = (wxImage *) &_result_ref;
10904 }
10905
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj;
10918 wxImage *arg1 = (wxImage *) 0 ;
10919 int arg2 ;
10920 int arg3 ;
10921 unsigned char arg4 ;
10922 unsigned char arg5 ;
10923 unsigned char arg6 ;
10924 PyObject * obj0 = 0 ;
10925 PyObject * obj1 = 0 ;
10926 PyObject * obj2 = 0 ;
10927 PyObject * obj3 = 0 ;
10928 PyObject * obj4 = 0 ;
10929 PyObject * obj5 = 0 ;
10930 char *kwnames[] = {
10931 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10932 };
10933
10934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10936 if (SWIG_arg_fail(1)) SWIG_fail;
10937 {
10938 arg2 = (int)(SWIG_As_int(obj1));
10939 if (SWIG_arg_fail(2)) SWIG_fail;
10940 }
10941 {
10942 arg3 = (int)(SWIG_As_int(obj2));
10943 if (SWIG_arg_fail(3)) SWIG_fail;
10944 }
10945 {
10946 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10947 if (SWIG_arg_fail(4)) SWIG_fail;
10948 }
10949 {
10950 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10951 if (SWIG_arg_fail(5)) SWIG_fail;
10952 }
10953 {
10954 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10955 if (SWIG_arg_fail(6)) SWIG_fail;
10956 }
10957 {
10958 PyThreadState* __tstate = wxPyBeginAllowThreads();
10959 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10960
10961 wxPyEndAllowThreads(__tstate);
10962 if (PyErr_Occurred()) SWIG_fail;
10963 }
10964 Py_INCREF(Py_None); resultobj = Py_None;
10965 return resultobj;
10966 fail:
10967 return NULL;
10968 }
10969
10970
10971 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10972 PyObject *resultobj;
10973 wxImage *arg1 = (wxImage *) 0 ;
10974 int arg2 ;
10975 int arg3 ;
10976 unsigned char result;
10977 PyObject * obj0 = 0 ;
10978 PyObject * obj1 = 0 ;
10979 PyObject * obj2 = 0 ;
10980 char *kwnames[] = {
10981 (char *) "self",(char *) "x",(char *) "y", NULL
10982 };
10983
10984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10986 if (SWIG_arg_fail(1)) SWIG_fail;
10987 {
10988 arg2 = (int)(SWIG_As_int(obj1));
10989 if (SWIG_arg_fail(2)) SWIG_fail;
10990 }
10991 {
10992 arg3 = (int)(SWIG_As_int(obj2));
10993 if (SWIG_arg_fail(3)) SWIG_fail;
10994 }
10995 {
10996 PyThreadState* __tstate = wxPyBeginAllowThreads();
10997 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
10998
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 {
11003 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11004 }
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj;
11013 wxImage *arg1 = (wxImage *) 0 ;
11014 int arg2 ;
11015 int arg3 ;
11016 unsigned char result;
11017 PyObject * obj0 = 0 ;
11018 PyObject * obj1 = 0 ;
11019 PyObject * obj2 = 0 ;
11020 char *kwnames[] = {
11021 (char *) "self",(char *) "x",(char *) "y", NULL
11022 };
11023
11024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11026 if (SWIG_arg_fail(1)) SWIG_fail;
11027 {
11028 arg2 = (int)(SWIG_As_int(obj1));
11029 if (SWIG_arg_fail(2)) SWIG_fail;
11030 }
11031 {
11032 arg3 = (int)(SWIG_As_int(obj2));
11033 if (SWIG_arg_fail(3)) SWIG_fail;
11034 }
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11038
11039 wxPyEndAllowThreads(__tstate);
11040 if (PyErr_Occurred()) SWIG_fail;
11041 }
11042 {
11043 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11044 }
11045 return resultobj;
11046 fail:
11047 return NULL;
11048 }
11049
11050
11051 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11052 PyObject *resultobj;
11053 wxImage *arg1 = (wxImage *) 0 ;
11054 int arg2 ;
11055 int arg3 ;
11056 unsigned char result;
11057 PyObject * obj0 = 0 ;
11058 PyObject * obj1 = 0 ;
11059 PyObject * obj2 = 0 ;
11060 char *kwnames[] = {
11061 (char *) "self",(char *) "x",(char *) "y", NULL
11062 };
11063
11064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11066 if (SWIG_arg_fail(1)) SWIG_fail;
11067 {
11068 arg2 = (int)(SWIG_As_int(obj1));
11069 if (SWIG_arg_fail(2)) SWIG_fail;
11070 }
11071 {
11072 arg3 = (int)(SWIG_As_int(obj2));
11073 if (SWIG_arg_fail(3)) SWIG_fail;
11074 }
11075 {
11076 PyThreadState* __tstate = wxPyBeginAllowThreads();
11077 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11078
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 {
11083 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11084 }
11085 return resultobj;
11086 fail:
11087 return NULL;
11088 }
11089
11090
11091 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11092 PyObject *resultobj;
11093 wxImage *arg1 = (wxImage *) 0 ;
11094 int arg2 ;
11095 int arg3 ;
11096 unsigned char arg4 ;
11097 PyObject * obj0 = 0 ;
11098 PyObject * obj1 = 0 ;
11099 PyObject * obj2 = 0 ;
11100 PyObject * obj3 = 0 ;
11101 char *kwnames[] = {
11102 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11103 };
11104
11105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11107 if (SWIG_arg_fail(1)) SWIG_fail;
11108 {
11109 arg2 = (int)(SWIG_As_int(obj1));
11110 if (SWIG_arg_fail(2)) SWIG_fail;
11111 }
11112 {
11113 arg3 = (int)(SWIG_As_int(obj2));
11114 if (SWIG_arg_fail(3)) SWIG_fail;
11115 }
11116 {
11117 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11118 if (SWIG_arg_fail(4)) SWIG_fail;
11119 }
11120 {
11121 PyThreadState* __tstate = wxPyBeginAllowThreads();
11122 (arg1)->SetAlpha(arg2,arg3,arg4);
11123
11124 wxPyEndAllowThreads(__tstate);
11125 if (PyErr_Occurred()) SWIG_fail;
11126 }
11127 Py_INCREF(Py_None); resultobj = Py_None;
11128 return resultobj;
11129 fail:
11130 return NULL;
11131 }
11132
11133
11134 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11135 PyObject *resultobj;
11136 wxImage *arg1 = (wxImage *) 0 ;
11137 int arg2 ;
11138 int arg3 ;
11139 unsigned char result;
11140 PyObject * obj0 = 0 ;
11141 PyObject * obj1 = 0 ;
11142 PyObject * obj2 = 0 ;
11143 char *kwnames[] = {
11144 (char *) "self",(char *) "x",(char *) "y", NULL
11145 };
11146
11147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11149 if (SWIG_arg_fail(1)) SWIG_fail;
11150 {
11151 arg2 = (int)(SWIG_As_int(obj1));
11152 if (SWIG_arg_fail(2)) SWIG_fail;
11153 }
11154 {
11155 arg3 = (int)(SWIG_As_int(obj2));
11156 if (SWIG_arg_fail(3)) SWIG_fail;
11157 }
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 {
11166 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11167 }
11168 return resultobj;
11169 fail:
11170 return NULL;
11171 }
11172
11173
11174 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11175 PyObject *resultobj;
11176 wxImage *arg1 = (wxImage *) 0 ;
11177 bool result;
11178 PyObject * obj0 = 0 ;
11179 char *kwnames[] = {
11180 (char *) "self", NULL
11181 };
11182
11183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11185 if (SWIG_arg_fail(1)) SWIG_fail;
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (bool)(arg1)->HasAlpha();
11189
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 {
11194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11195 }
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11203 PyObject *resultobj;
11204 wxImage *arg1 = (wxImage *) 0 ;
11205 PyObject * obj0 = 0 ;
11206 char *kwnames[] = {
11207 (char *) "self", NULL
11208 };
11209
11210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11212 if (SWIG_arg_fail(1)) SWIG_fail;
11213 {
11214 PyThreadState* __tstate = wxPyBeginAllowThreads();
11215 (arg1)->InitAlpha();
11216
11217 wxPyEndAllowThreads(__tstate);
11218 if (PyErr_Occurred()) SWIG_fail;
11219 }
11220 Py_INCREF(Py_None); resultobj = Py_None;
11221 return resultobj;
11222 fail:
11223 return NULL;
11224 }
11225
11226
11227 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11228 PyObject *resultobj;
11229 wxImage *arg1 = (wxImage *) 0 ;
11230 byte *arg2 = (byte *) 0 ;
11231 byte *arg3 = (byte *) 0 ;
11232 byte *arg4 = (byte *) 0 ;
11233 byte arg5 = (byte) 0 ;
11234 byte arg6 = (byte) 0 ;
11235 byte arg7 = (byte) 0 ;
11236 bool result;
11237 byte temp2 ;
11238 int res2 = 0 ;
11239 byte temp3 ;
11240 int res3 = 0 ;
11241 byte temp4 ;
11242 int res4 = 0 ;
11243 PyObject * obj0 = 0 ;
11244 PyObject * obj1 = 0 ;
11245 PyObject * obj2 = 0 ;
11246 PyObject * obj3 = 0 ;
11247 char *kwnames[] = {
11248 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11249 };
11250
11251 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11252 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11253 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11256 if (SWIG_arg_fail(1)) SWIG_fail;
11257 if (obj1) {
11258 {
11259 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11260 if (SWIG_arg_fail(5)) SWIG_fail;
11261 }
11262 }
11263 if (obj2) {
11264 {
11265 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11266 if (SWIG_arg_fail(6)) SWIG_fail;
11267 }
11268 }
11269 if (obj3) {
11270 {
11271 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11272 if (SWIG_arg_fail(7)) SWIG_fail;
11273 }
11274 }
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11278
11279 wxPyEndAllowThreads(__tstate);
11280 if (PyErr_Occurred()) SWIG_fail;
11281 }
11282 {
11283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11284 }
11285 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11286 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11287 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11288 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11289 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11290 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11291 return resultobj;
11292 fail:
11293 return NULL;
11294 }
11295
11296
11297 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11298 PyObject *resultobj;
11299 wxImage *arg1 = (wxImage *) 0 ;
11300 byte arg2 = (byte) 128 ;
11301 bool result;
11302 PyObject * obj0 = 0 ;
11303 PyObject * obj1 = 0 ;
11304 char *kwnames[] = {
11305 (char *) "self",(char *) "threshold", NULL
11306 };
11307
11308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11310 if (SWIG_arg_fail(1)) SWIG_fail;
11311 if (obj1) {
11312 {
11313 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11314 if (SWIG_arg_fail(2)) SWIG_fail;
11315 }
11316 }
11317 {
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11320
11321 wxPyEndAllowThreads(__tstate);
11322 if (PyErr_Occurred()) SWIG_fail;
11323 }
11324 {
11325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11326 }
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11334 PyObject *resultobj;
11335 wxImage *arg1 = (wxImage *) 0 ;
11336 unsigned char arg2 ;
11337 unsigned char arg3 ;
11338 unsigned char arg4 ;
11339 bool result;
11340 PyObject * obj0 = 0 ;
11341 PyObject * obj1 = 0 ;
11342 PyObject * obj2 = 0 ;
11343 PyObject * obj3 = 0 ;
11344 char *kwnames[] = {
11345 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11346 };
11347
11348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11350 if (SWIG_arg_fail(1)) SWIG_fail;
11351 {
11352 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11353 if (SWIG_arg_fail(2)) SWIG_fail;
11354 }
11355 {
11356 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11357 if (SWIG_arg_fail(3)) SWIG_fail;
11358 }
11359 {
11360 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11361 if (SWIG_arg_fail(4)) SWIG_fail;
11362 }
11363 {
11364 PyThreadState* __tstate = wxPyBeginAllowThreads();
11365 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11366
11367 wxPyEndAllowThreads(__tstate);
11368 if (PyErr_Occurred()) SWIG_fail;
11369 }
11370 {
11371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11372 }
11373 return resultobj;
11374 fail:
11375 return NULL;
11376 }
11377
11378
11379 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11380 PyObject *resultobj;
11381 wxImage *arg1 = (wxImage *) 0 ;
11382 wxImage *arg2 = 0 ;
11383 byte arg3 ;
11384 byte arg4 ;
11385 byte arg5 ;
11386 bool result;
11387 PyObject * obj0 = 0 ;
11388 PyObject * obj1 = 0 ;
11389 PyObject * obj2 = 0 ;
11390 PyObject * obj3 = 0 ;
11391 PyObject * obj4 = 0 ;
11392 char *kwnames[] = {
11393 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11394 };
11395
11396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11398 if (SWIG_arg_fail(1)) SWIG_fail;
11399 {
11400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11401 if (SWIG_arg_fail(2)) SWIG_fail;
11402 if (arg2 == NULL) {
11403 SWIG_null_ref("wxImage");
11404 }
11405 if (SWIG_arg_fail(2)) SWIG_fail;
11406 }
11407 {
11408 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11409 if (SWIG_arg_fail(3)) SWIG_fail;
11410 }
11411 {
11412 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11413 if (SWIG_arg_fail(4)) SWIG_fail;
11414 }
11415 {
11416 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11417 if (SWIG_arg_fail(5)) SWIG_fail;
11418 }
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11422
11423 wxPyEndAllowThreads(__tstate);
11424 if (PyErr_Occurred()) SWIG_fail;
11425 }
11426 {
11427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11428 }
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj;
11437 wxString *arg1 = 0 ;
11438 bool result;
11439 bool temp1 = false ;
11440 PyObject * obj0 = 0 ;
11441 char *kwnames[] = {
11442 (char *) "name", NULL
11443 };
11444
11445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11446 {
11447 arg1 = wxString_in_helper(obj0);
11448 if (arg1 == NULL) SWIG_fail;
11449 temp1 = true;
11450 }
11451 {
11452 PyThreadState* __tstate = wxPyBeginAllowThreads();
11453 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11454
11455 wxPyEndAllowThreads(__tstate);
11456 if (PyErr_Occurred()) SWIG_fail;
11457 }
11458 {
11459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11460 }
11461 {
11462 if (temp1)
11463 delete arg1;
11464 }
11465 return resultobj;
11466 fail:
11467 {
11468 if (temp1)
11469 delete arg1;
11470 }
11471 return NULL;
11472 }
11473
11474
11475 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11476 PyObject *resultobj;
11477 wxString *arg1 = 0 ;
11478 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11479 int result;
11480 bool temp1 = false ;
11481 PyObject * obj0 = 0 ;
11482 PyObject * obj1 = 0 ;
11483 char *kwnames[] = {
11484 (char *) "name",(char *) "type", NULL
11485 };
11486
11487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11488 {
11489 arg1 = wxString_in_helper(obj0);
11490 if (arg1 == NULL) SWIG_fail;
11491 temp1 = true;
11492 }
11493 if (obj1) {
11494 {
11495 arg2 = (long)(SWIG_As_long(obj1));
11496 if (SWIG_arg_fail(2)) SWIG_fail;
11497 }
11498 }
11499 {
11500 PyThreadState* __tstate = wxPyBeginAllowThreads();
11501 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11502
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 {
11507 resultobj = SWIG_From_int((int)(result));
11508 }
11509 {
11510 if (temp1)
11511 delete arg1;
11512 }
11513 return resultobj;
11514 fail:
11515 {
11516 if (temp1)
11517 delete arg1;
11518 }
11519 return NULL;
11520 }
11521
11522
11523 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11524 PyObject *resultobj;
11525 wxImage *arg1 = (wxImage *) 0 ;
11526 wxString *arg2 = 0 ;
11527 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11528 int arg4 = (int) -1 ;
11529 bool result;
11530 bool temp2 = false ;
11531 PyObject * obj0 = 0 ;
11532 PyObject * obj1 = 0 ;
11533 PyObject * obj2 = 0 ;
11534 PyObject * obj3 = 0 ;
11535 char *kwnames[] = {
11536 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11537 };
11538
11539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11541 if (SWIG_arg_fail(1)) SWIG_fail;
11542 {
11543 arg2 = wxString_in_helper(obj1);
11544 if (arg2 == NULL) SWIG_fail;
11545 temp2 = true;
11546 }
11547 if (obj2) {
11548 {
11549 arg3 = (long)(SWIG_As_long(obj2));
11550 if (SWIG_arg_fail(3)) SWIG_fail;
11551 }
11552 }
11553 if (obj3) {
11554 {
11555 arg4 = (int)(SWIG_As_int(obj3));
11556 if (SWIG_arg_fail(4)) SWIG_fail;
11557 }
11558 }
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11562
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 {
11567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11568 }
11569 {
11570 if (temp2)
11571 delete arg2;
11572 }
11573 return resultobj;
11574 fail:
11575 {
11576 if (temp2)
11577 delete arg2;
11578 }
11579 return NULL;
11580 }
11581
11582
11583 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj;
11585 wxImage *arg1 = (wxImage *) 0 ;
11586 wxString *arg2 = 0 ;
11587 wxString *arg3 = 0 ;
11588 int arg4 = (int) -1 ;
11589 bool result;
11590 bool temp2 = false ;
11591 bool temp3 = false ;
11592 PyObject * obj0 = 0 ;
11593 PyObject * obj1 = 0 ;
11594 PyObject * obj2 = 0 ;
11595 PyObject * obj3 = 0 ;
11596 char *kwnames[] = {
11597 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11598 };
11599
11600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11602 if (SWIG_arg_fail(1)) SWIG_fail;
11603 {
11604 arg2 = wxString_in_helper(obj1);
11605 if (arg2 == NULL) SWIG_fail;
11606 temp2 = true;
11607 }
11608 {
11609 arg3 = wxString_in_helper(obj2);
11610 if (arg3 == NULL) SWIG_fail;
11611 temp3 = true;
11612 }
11613 if (obj3) {
11614 {
11615 arg4 = (int)(SWIG_As_int(obj3));
11616 if (SWIG_arg_fail(4)) SWIG_fail;
11617 }
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11622
11623 wxPyEndAllowThreads(__tstate);
11624 if (PyErr_Occurred()) SWIG_fail;
11625 }
11626 {
11627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11628 }
11629 {
11630 if (temp2)
11631 delete arg2;
11632 }
11633 {
11634 if (temp3)
11635 delete arg3;
11636 }
11637 return resultobj;
11638 fail:
11639 {
11640 if (temp2)
11641 delete arg2;
11642 }
11643 {
11644 if (temp3)
11645 delete arg3;
11646 }
11647 return NULL;
11648 }
11649
11650
11651 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11652 PyObject *resultobj;
11653 wxImage *arg1 = (wxImage *) 0 ;
11654 wxString *arg2 = 0 ;
11655 int arg3 ;
11656 bool result;
11657 bool temp2 = false ;
11658 PyObject * obj0 = 0 ;
11659 PyObject * obj1 = 0 ;
11660 PyObject * obj2 = 0 ;
11661 char *kwnames[] = {
11662 (char *) "self",(char *) "name",(char *) "type", NULL
11663 };
11664
11665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11667 if (SWIG_arg_fail(1)) SWIG_fail;
11668 {
11669 arg2 = wxString_in_helper(obj1);
11670 if (arg2 == NULL) SWIG_fail;
11671 temp2 = true;
11672 }
11673 {
11674 arg3 = (int)(SWIG_As_int(obj2));
11675 if (SWIG_arg_fail(3)) SWIG_fail;
11676 }
11677 {
11678 PyThreadState* __tstate = wxPyBeginAllowThreads();
11679 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11680
11681 wxPyEndAllowThreads(__tstate);
11682 if (PyErr_Occurred()) SWIG_fail;
11683 }
11684 {
11685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11686 }
11687 {
11688 if (temp2)
11689 delete arg2;
11690 }
11691 return resultobj;
11692 fail:
11693 {
11694 if (temp2)
11695 delete arg2;
11696 }
11697 return NULL;
11698 }
11699
11700
11701 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11702 PyObject *resultobj;
11703 wxImage *arg1 = (wxImage *) 0 ;
11704 wxString *arg2 = 0 ;
11705 wxString *arg3 = 0 ;
11706 bool result;
11707 bool temp2 = false ;
11708 bool temp3 = false ;
11709 PyObject * obj0 = 0 ;
11710 PyObject * obj1 = 0 ;
11711 PyObject * obj2 = 0 ;
11712 char *kwnames[] = {
11713 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11714 };
11715
11716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11718 if (SWIG_arg_fail(1)) SWIG_fail;
11719 {
11720 arg2 = wxString_in_helper(obj1);
11721 if (arg2 == NULL) SWIG_fail;
11722 temp2 = true;
11723 }
11724 {
11725 arg3 = wxString_in_helper(obj2);
11726 if (arg3 == NULL) SWIG_fail;
11727 temp3 = true;
11728 }
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11732
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11738 }
11739 {
11740 if (temp2)
11741 delete arg2;
11742 }
11743 {
11744 if (temp3)
11745 delete arg3;
11746 }
11747 return resultobj;
11748 fail:
11749 {
11750 if (temp2)
11751 delete arg2;
11752 }
11753 {
11754 if (temp3)
11755 delete arg3;
11756 }
11757 return NULL;
11758 }
11759
11760
11761 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11762 PyObject *resultobj;
11763 wxInputStream *arg1 = 0 ;
11764 bool result;
11765 wxPyInputStream *temp1 ;
11766 bool created1 ;
11767 PyObject * obj0 = 0 ;
11768 char *kwnames[] = {
11769 (char *) "stream", NULL
11770 };
11771
11772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11773 {
11774 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11775 arg1 = temp1->m_wxis;
11776 created1 = false;
11777 } else {
11778 PyErr_Clear(); // clear the failure of the wxPyConvert above
11779 arg1 = wxPyCBInputStream_create(obj0, false);
11780 if (arg1 == NULL) {
11781 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11782 SWIG_fail;
11783 }
11784 created1 = true;
11785 }
11786 }
11787 {
11788 PyThreadState* __tstate = wxPyBeginAllowThreads();
11789 result = (bool)wxImage::CanRead(*arg1);
11790
11791 wxPyEndAllowThreads(__tstate);
11792 if (PyErr_Occurred()) SWIG_fail;
11793 }
11794 {
11795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11796 }
11797 {
11798 if (created1) delete arg1;
11799 }
11800 return resultobj;
11801 fail:
11802 {
11803 if (created1) delete arg1;
11804 }
11805 return NULL;
11806 }
11807
11808
11809 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11810 PyObject *resultobj;
11811 wxImage *arg1 = (wxImage *) 0 ;
11812 wxInputStream *arg2 = 0 ;
11813 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11814 int arg4 = (int) -1 ;
11815 bool result;
11816 wxPyInputStream *temp2 ;
11817 bool created2 ;
11818 PyObject * obj0 = 0 ;
11819 PyObject * obj1 = 0 ;
11820 PyObject * obj2 = 0 ;
11821 PyObject * obj3 = 0 ;
11822 char *kwnames[] = {
11823 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11824 };
11825
11826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11828 if (SWIG_arg_fail(1)) SWIG_fail;
11829 {
11830 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11831 arg2 = temp2->m_wxis;
11832 created2 = false;
11833 } else {
11834 PyErr_Clear(); // clear the failure of the wxPyConvert above
11835 arg2 = wxPyCBInputStream_create(obj1, false);
11836 if (arg2 == NULL) {
11837 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11838 SWIG_fail;
11839 }
11840 created2 = true;
11841 }
11842 }
11843 if (obj2) {
11844 {
11845 arg3 = (long)(SWIG_As_long(obj2));
11846 if (SWIG_arg_fail(3)) SWIG_fail;
11847 }
11848 }
11849 if (obj3) {
11850 {
11851 arg4 = (int)(SWIG_As_int(obj3));
11852 if (SWIG_arg_fail(4)) SWIG_fail;
11853 }
11854 }
11855 {
11856 PyThreadState* __tstate = wxPyBeginAllowThreads();
11857 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11858
11859 wxPyEndAllowThreads(__tstate);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 {
11863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11864 }
11865 {
11866 if (created2) delete arg2;
11867 }
11868 return resultobj;
11869 fail:
11870 {
11871 if (created2) delete arg2;
11872 }
11873 return NULL;
11874 }
11875
11876
11877 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11878 PyObject *resultobj;
11879 wxImage *arg1 = (wxImage *) 0 ;
11880 wxInputStream *arg2 = 0 ;
11881 wxString *arg3 = 0 ;
11882 int arg4 = (int) -1 ;
11883 bool result;
11884 wxPyInputStream *temp2 ;
11885 bool created2 ;
11886 bool temp3 = false ;
11887 PyObject * obj0 = 0 ;
11888 PyObject * obj1 = 0 ;
11889 PyObject * obj2 = 0 ;
11890 PyObject * obj3 = 0 ;
11891 char *kwnames[] = {
11892 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11893 };
11894
11895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11897 if (SWIG_arg_fail(1)) SWIG_fail;
11898 {
11899 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11900 arg2 = temp2->m_wxis;
11901 created2 = false;
11902 } else {
11903 PyErr_Clear(); // clear the failure of the wxPyConvert above
11904 arg2 = wxPyCBInputStream_create(obj1, false);
11905 if (arg2 == NULL) {
11906 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11907 SWIG_fail;
11908 }
11909 created2 = true;
11910 }
11911 }
11912 {
11913 arg3 = wxString_in_helper(obj2);
11914 if (arg3 == NULL) SWIG_fail;
11915 temp3 = true;
11916 }
11917 if (obj3) {
11918 {
11919 arg4 = (int)(SWIG_As_int(obj3));
11920 if (SWIG_arg_fail(4)) SWIG_fail;
11921 }
11922 }
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11926
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 {
11931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11932 }
11933 {
11934 if (created2) delete arg2;
11935 }
11936 {
11937 if (temp3)
11938 delete arg3;
11939 }
11940 return resultobj;
11941 fail:
11942 {
11943 if (created2) delete arg2;
11944 }
11945 {
11946 if (temp3)
11947 delete arg3;
11948 }
11949 return NULL;
11950 }
11951
11952
11953 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11954 PyObject *resultobj;
11955 wxImage *arg1 = (wxImage *) 0 ;
11956 bool result;
11957 PyObject * obj0 = 0 ;
11958 char *kwnames[] = {
11959 (char *) "self", NULL
11960 };
11961
11962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11964 if (SWIG_arg_fail(1)) SWIG_fail;
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (bool)(arg1)->Ok();
11968
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 {
11973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11974 }
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11982 PyObject *resultobj;
11983 wxImage *arg1 = (wxImage *) 0 ;
11984 int result;
11985 PyObject * obj0 = 0 ;
11986 char *kwnames[] = {
11987 (char *) "self", NULL
11988 };
11989
11990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11992 if (SWIG_arg_fail(1)) SWIG_fail;
11993 {
11994 PyThreadState* __tstate = wxPyBeginAllowThreads();
11995 result = (int)(arg1)->GetWidth();
11996
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 {
12001 resultobj = SWIG_From_int((int)(result));
12002 }
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12010 PyObject *resultobj;
12011 wxImage *arg1 = (wxImage *) 0 ;
12012 int result;
12013 PyObject * obj0 = 0 ;
12014 char *kwnames[] = {
12015 (char *) "self", NULL
12016 };
12017
12018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12020 if (SWIG_arg_fail(1)) SWIG_fail;
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 result = (int)(arg1)->GetHeight();
12024
12025 wxPyEndAllowThreads(__tstate);
12026 if (PyErr_Occurred()) SWIG_fail;
12027 }
12028 {
12029 resultobj = SWIG_From_int((int)(result));
12030 }
12031 return resultobj;
12032 fail:
12033 return NULL;
12034 }
12035
12036
12037 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj;
12039 wxImage *arg1 = (wxImage *) 0 ;
12040 wxSize result;
12041 PyObject * obj0 = 0 ;
12042 char *kwnames[] = {
12043 (char *) "self", NULL
12044 };
12045
12046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12048 if (SWIG_arg_fail(1)) SWIG_fail;
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = wxImage_GetSize(arg1);
12052
12053 wxPyEndAllowThreads(__tstate);
12054 if (PyErr_Occurred()) SWIG_fail;
12055 }
12056 {
12057 wxSize * resultptr;
12058 resultptr = new wxSize((wxSize &)(result));
12059 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12060 }
12061 return resultobj;
12062 fail:
12063 return NULL;
12064 }
12065
12066
12067 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12068 PyObject *resultobj;
12069 wxImage *arg1 = (wxImage *) 0 ;
12070 wxRect *arg2 = 0 ;
12071 SwigValueWrapper<wxImage > result;
12072 wxRect temp2 ;
12073 PyObject * obj0 = 0 ;
12074 PyObject * obj1 = 0 ;
12075 char *kwnames[] = {
12076 (char *) "self",(char *) "rect", NULL
12077 };
12078
12079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12081 if (SWIG_arg_fail(1)) SWIG_fail;
12082 {
12083 arg2 = &temp2;
12084 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12085 }
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12089
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 {
12094 wxImage * resultptr;
12095 resultptr = new wxImage((wxImage &)(result));
12096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12097 }
12098 return resultobj;
12099 fail:
12100 return NULL;
12101 }
12102
12103
12104 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12105 PyObject *resultobj;
12106 wxImage *arg1 = (wxImage *) 0 ;
12107 SwigValueWrapper<wxImage > result;
12108 PyObject * obj0 = 0 ;
12109 char *kwnames[] = {
12110 (char *) "self", NULL
12111 };
12112
12113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12115 if (SWIG_arg_fail(1)) SWIG_fail;
12116 {
12117 PyThreadState* __tstate = wxPyBeginAllowThreads();
12118 result = (arg1)->Copy();
12119
12120 wxPyEndAllowThreads(__tstate);
12121 if (PyErr_Occurred()) SWIG_fail;
12122 }
12123 {
12124 wxImage * resultptr;
12125 resultptr = new wxImage((wxImage &)(result));
12126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12127 }
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj;
12136 wxImage *arg1 = (wxImage *) 0 ;
12137 wxImage *arg2 = 0 ;
12138 int arg3 ;
12139 int arg4 ;
12140 PyObject * obj0 = 0 ;
12141 PyObject * obj1 = 0 ;
12142 PyObject * obj2 = 0 ;
12143 PyObject * obj3 = 0 ;
12144 char *kwnames[] = {
12145 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12146 };
12147
12148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12150 if (SWIG_arg_fail(1)) SWIG_fail;
12151 {
12152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12153 if (SWIG_arg_fail(2)) SWIG_fail;
12154 if (arg2 == NULL) {
12155 SWIG_null_ref("wxImage");
12156 }
12157 if (SWIG_arg_fail(2)) SWIG_fail;
12158 }
12159 {
12160 arg3 = (int)(SWIG_As_int(obj2));
12161 if (SWIG_arg_fail(3)) SWIG_fail;
12162 }
12163 {
12164 arg4 = (int)(SWIG_As_int(obj3));
12165 if (SWIG_arg_fail(4)) SWIG_fail;
12166 }
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12170
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 Py_INCREF(Py_None); resultobj = Py_None;
12175 return resultobj;
12176 fail:
12177 return NULL;
12178 }
12179
12180
12181 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12182 PyObject *resultobj;
12183 wxImage *arg1 = (wxImage *) 0 ;
12184 PyObject *result;
12185 PyObject * obj0 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 {
12194 PyThreadState* __tstate = wxPyBeginAllowThreads();
12195 result = (PyObject *)wxImage_GetData(arg1);
12196
12197 wxPyEndAllowThreads(__tstate);
12198 if (PyErr_Occurred()) SWIG_fail;
12199 }
12200 resultobj = result;
12201 return resultobj;
12202 fail:
12203 return NULL;
12204 }
12205
12206
12207 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12208 PyObject *resultobj;
12209 wxImage *arg1 = (wxImage *) 0 ;
12210 PyObject *arg2 = (PyObject *) 0 ;
12211 PyObject * obj0 = 0 ;
12212 PyObject * obj1 = 0 ;
12213 char *kwnames[] = {
12214 (char *) "self",(char *) "data", NULL
12215 };
12216
12217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12219 if (SWIG_arg_fail(1)) SWIG_fail;
12220 arg2 = obj1;
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 wxImage_SetData(arg1,arg2);
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 Py_INCREF(Py_None); resultobj = Py_None;
12229 return resultobj;
12230 fail:
12231 return NULL;
12232 }
12233
12234
12235 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12236 PyObject *resultobj;
12237 wxImage *arg1 = (wxImage *) 0 ;
12238 PyObject *result;
12239 PyObject * obj0 = 0 ;
12240 char *kwnames[] = {
12241 (char *) "self", NULL
12242 };
12243
12244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12246 if (SWIG_arg_fail(1)) SWIG_fail;
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12250
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 resultobj = result;
12255 return resultobj;
12256 fail:
12257 return NULL;
12258 }
12259
12260
12261 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12262 PyObject *resultobj;
12263 wxImage *arg1 = (wxImage *) 0 ;
12264 PyObject *arg2 = (PyObject *) 0 ;
12265 PyObject * obj0 = 0 ;
12266 PyObject * obj1 = 0 ;
12267 char *kwnames[] = {
12268 (char *) "self",(char *) "data", NULL
12269 };
12270
12271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12273 if (SWIG_arg_fail(1)) SWIG_fail;
12274 arg2 = obj1;
12275 {
12276 PyThreadState* __tstate = wxPyBeginAllowThreads();
12277 wxImage_SetDataBuffer(arg1,arg2);
12278
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 Py_INCREF(Py_None); resultobj = Py_None;
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj;
12291 wxImage *arg1 = (wxImage *) 0 ;
12292 PyObject *result;
12293 PyObject * obj0 = 0 ;
12294 char *kwnames[] = {
12295 (char *) "self", NULL
12296 };
12297
12298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12300 if (SWIG_arg_fail(1)) SWIG_fail;
12301 {
12302 PyThreadState* __tstate = wxPyBeginAllowThreads();
12303 result = (PyObject *)wxImage_GetAlphaData(arg1);
12304
12305 wxPyEndAllowThreads(__tstate);
12306 if (PyErr_Occurred()) SWIG_fail;
12307 }
12308 resultobj = result;
12309 return resultobj;
12310 fail:
12311 return NULL;
12312 }
12313
12314
12315 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12316 PyObject *resultobj;
12317 wxImage *arg1 = (wxImage *) 0 ;
12318 PyObject *arg2 = (PyObject *) 0 ;
12319 PyObject * obj0 = 0 ;
12320 PyObject * obj1 = 0 ;
12321 char *kwnames[] = {
12322 (char *) "self",(char *) "data", NULL
12323 };
12324
12325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12327 if (SWIG_arg_fail(1)) SWIG_fail;
12328 arg2 = obj1;
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 wxImage_SetAlphaData(arg1,arg2);
12332
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 Py_INCREF(Py_None); resultobj = Py_None;
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj;
12345 wxImage *arg1 = (wxImage *) 0 ;
12346 PyObject *result;
12347 PyObject * obj0 = 0 ;
12348 char *kwnames[] = {
12349 (char *) "self", NULL
12350 };
12351
12352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12354 if (SWIG_arg_fail(1)) SWIG_fail;
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12358
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 resultobj = result;
12363 return resultobj;
12364 fail:
12365 return NULL;
12366 }
12367
12368
12369 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12370 PyObject *resultobj;
12371 wxImage *arg1 = (wxImage *) 0 ;
12372 PyObject *arg2 = (PyObject *) 0 ;
12373 PyObject * obj0 = 0 ;
12374 PyObject * obj1 = 0 ;
12375 char *kwnames[] = {
12376 (char *) "self",(char *) "data", NULL
12377 };
12378
12379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12381 if (SWIG_arg_fail(1)) SWIG_fail;
12382 arg2 = obj1;
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 wxImage_SetAlphaBuffer(arg1,arg2);
12386
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 Py_INCREF(Py_None); resultobj = Py_None;
12391 return resultobj;
12392 fail:
12393 return NULL;
12394 }
12395
12396
12397 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12398 PyObject *resultobj;
12399 wxImage *arg1 = (wxImage *) 0 ;
12400 unsigned char arg2 ;
12401 unsigned char arg3 ;
12402 unsigned char arg4 ;
12403 PyObject * obj0 = 0 ;
12404 PyObject * obj1 = 0 ;
12405 PyObject * obj2 = 0 ;
12406 PyObject * obj3 = 0 ;
12407 char *kwnames[] = {
12408 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12409 };
12410
12411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12413 if (SWIG_arg_fail(1)) SWIG_fail;
12414 {
12415 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12416 if (SWIG_arg_fail(2)) SWIG_fail;
12417 }
12418 {
12419 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12420 if (SWIG_arg_fail(3)) SWIG_fail;
12421 }
12422 {
12423 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12424 if (SWIG_arg_fail(4)) SWIG_fail;
12425 }
12426 {
12427 PyThreadState* __tstate = wxPyBeginAllowThreads();
12428 (arg1)->SetMaskColour(arg2,arg3,arg4);
12429
12430 wxPyEndAllowThreads(__tstate);
12431 if (PyErr_Occurred()) SWIG_fail;
12432 }
12433 Py_INCREF(Py_None); resultobj = Py_None;
12434 return resultobj;
12435 fail:
12436 return NULL;
12437 }
12438
12439
12440 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12441 PyObject *resultobj;
12442 wxImage *arg1 = (wxImage *) 0 ;
12443 unsigned char result;
12444 PyObject * obj0 = 0 ;
12445 char *kwnames[] = {
12446 (char *) "self", NULL
12447 };
12448
12449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12451 if (SWIG_arg_fail(1)) SWIG_fail;
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = (unsigned char)(arg1)->GetMaskRed();
12455
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 {
12460 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12461 }
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj;
12470 wxImage *arg1 = (wxImage *) 0 ;
12471 unsigned char result;
12472 PyObject * obj0 = 0 ;
12473 char *kwnames[] = {
12474 (char *) "self", NULL
12475 };
12476
12477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12479 if (SWIG_arg_fail(1)) SWIG_fail;
12480 {
12481 PyThreadState* __tstate = wxPyBeginAllowThreads();
12482 result = (unsigned char)(arg1)->GetMaskGreen();
12483
12484 wxPyEndAllowThreads(__tstate);
12485 if (PyErr_Occurred()) SWIG_fail;
12486 }
12487 {
12488 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12489 }
12490 return resultobj;
12491 fail:
12492 return NULL;
12493 }
12494
12495
12496 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12497 PyObject *resultobj;
12498 wxImage *arg1 = (wxImage *) 0 ;
12499 unsigned char result;
12500 PyObject * obj0 = 0 ;
12501 char *kwnames[] = {
12502 (char *) "self", NULL
12503 };
12504
12505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12507 if (SWIG_arg_fail(1)) SWIG_fail;
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 result = (unsigned char)(arg1)->GetMaskBlue();
12511
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 {
12516 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12517 }
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12525 PyObject *resultobj;
12526 wxImage *arg1 = (wxImage *) 0 ;
12527 bool arg2 = (bool) true ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 char *kwnames[] = {
12531 (char *) "self",(char *) "mask", NULL
12532 };
12533
12534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12536 if (SWIG_arg_fail(1)) SWIG_fail;
12537 if (obj1) {
12538 {
12539 arg2 = (bool)(SWIG_As_bool(obj1));
12540 if (SWIG_arg_fail(2)) SWIG_fail;
12541 }
12542 }
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 (arg1)->SetMask(arg2);
12546
12547 wxPyEndAllowThreads(__tstate);
12548 if (PyErr_Occurred()) SWIG_fail;
12549 }
12550 Py_INCREF(Py_None); resultobj = Py_None;
12551 return resultobj;
12552 fail:
12553 return NULL;
12554 }
12555
12556
12557 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12558 PyObject *resultobj;
12559 wxImage *arg1 = (wxImage *) 0 ;
12560 bool result;
12561 PyObject * obj0 = 0 ;
12562 char *kwnames[] = {
12563 (char *) "self", NULL
12564 };
12565
12566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12568 if (SWIG_arg_fail(1)) SWIG_fail;
12569 {
12570 PyThreadState* __tstate = wxPyBeginAllowThreads();
12571 result = (bool)(arg1)->HasMask();
12572
12573 wxPyEndAllowThreads(__tstate);
12574 if (PyErr_Occurred()) SWIG_fail;
12575 }
12576 {
12577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12578 }
12579 return resultobj;
12580 fail:
12581 return NULL;
12582 }
12583
12584
12585 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12586 PyObject *resultobj;
12587 wxImage *arg1 = (wxImage *) 0 ;
12588 double arg2 ;
12589 wxPoint *arg3 = 0 ;
12590 bool arg4 = (bool) true ;
12591 wxPoint *arg5 = (wxPoint *) NULL ;
12592 SwigValueWrapper<wxImage > result;
12593 wxPoint temp3 ;
12594 PyObject * obj0 = 0 ;
12595 PyObject * obj1 = 0 ;
12596 PyObject * obj2 = 0 ;
12597 PyObject * obj3 = 0 ;
12598 PyObject * obj4 = 0 ;
12599 char *kwnames[] = {
12600 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12601 };
12602
12603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12605 if (SWIG_arg_fail(1)) SWIG_fail;
12606 {
12607 arg2 = (double)(SWIG_As_double(obj1));
12608 if (SWIG_arg_fail(2)) SWIG_fail;
12609 }
12610 {
12611 arg3 = &temp3;
12612 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12613 }
12614 if (obj3) {
12615 {
12616 arg4 = (bool)(SWIG_As_bool(obj3));
12617 if (SWIG_arg_fail(4)) SWIG_fail;
12618 }
12619 }
12620 if (obj4) {
12621 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12622 if (SWIG_arg_fail(5)) SWIG_fail;
12623 }
12624 {
12625 PyThreadState* __tstate = wxPyBeginAllowThreads();
12626 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12627
12628 wxPyEndAllowThreads(__tstate);
12629 if (PyErr_Occurred()) SWIG_fail;
12630 }
12631 {
12632 wxImage * resultptr;
12633 resultptr = new wxImage((wxImage &)(result));
12634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12635 }
12636 return resultobj;
12637 fail:
12638 return NULL;
12639 }
12640
12641
12642 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12643 PyObject *resultobj;
12644 wxImage *arg1 = (wxImage *) 0 ;
12645 bool arg2 = (bool) true ;
12646 SwigValueWrapper<wxImage > result;
12647 PyObject * obj0 = 0 ;
12648 PyObject * obj1 = 0 ;
12649 char *kwnames[] = {
12650 (char *) "self",(char *) "clockwise", NULL
12651 };
12652
12653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12655 if (SWIG_arg_fail(1)) SWIG_fail;
12656 if (obj1) {
12657 {
12658 arg2 = (bool)(SWIG_As_bool(obj1));
12659 if (SWIG_arg_fail(2)) SWIG_fail;
12660 }
12661 }
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 result = (arg1)->Rotate90(arg2);
12665
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 {
12670 wxImage * resultptr;
12671 resultptr = new wxImage((wxImage &)(result));
12672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12673 }
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12681 PyObject *resultobj;
12682 wxImage *arg1 = (wxImage *) 0 ;
12683 bool arg2 = (bool) true ;
12684 SwigValueWrapper<wxImage > result;
12685 PyObject * obj0 = 0 ;
12686 PyObject * obj1 = 0 ;
12687 char *kwnames[] = {
12688 (char *) "self",(char *) "horizontally", NULL
12689 };
12690
12691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12693 if (SWIG_arg_fail(1)) SWIG_fail;
12694 if (obj1) {
12695 {
12696 arg2 = (bool)(SWIG_As_bool(obj1));
12697 if (SWIG_arg_fail(2)) SWIG_fail;
12698 }
12699 }
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 result = (arg1)->Mirror(arg2);
12703
12704 wxPyEndAllowThreads(__tstate);
12705 if (PyErr_Occurred()) SWIG_fail;
12706 }
12707 {
12708 wxImage * resultptr;
12709 resultptr = new wxImage((wxImage &)(result));
12710 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12711 }
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12719 PyObject *resultobj;
12720 wxImage *arg1 = (wxImage *) 0 ;
12721 unsigned char arg2 ;
12722 unsigned char arg3 ;
12723 unsigned char arg4 ;
12724 unsigned char arg5 ;
12725 unsigned char arg6 ;
12726 unsigned char arg7 ;
12727 PyObject * obj0 = 0 ;
12728 PyObject * obj1 = 0 ;
12729 PyObject * obj2 = 0 ;
12730 PyObject * obj3 = 0 ;
12731 PyObject * obj4 = 0 ;
12732 PyObject * obj5 = 0 ;
12733 PyObject * obj6 = 0 ;
12734 char *kwnames[] = {
12735 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12736 };
12737
12738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12743 if (SWIG_arg_fail(2)) SWIG_fail;
12744 }
12745 {
12746 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12747 if (SWIG_arg_fail(3)) SWIG_fail;
12748 }
12749 {
12750 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12751 if (SWIG_arg_fail(4)) SWIG_fail;
12752 }
12753 {
12754 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12755 if (SWIG_arg_fail(5)) SWIG_fail;
12756 }
12757 {
12758 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12759 if (SWIG_arg_fail(6)) SWIG_fail;
12760 }
12761 {
12762 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12763 if (SWIG_arg_fail(7)) SWIG_fail;
12764 }
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12768
12769 wxPyEndAllowThreads(__tstate);
12770 if (PyErr_Occurred()) SWIG_fail;
12771 }
12772 Py_INCREF(Py_None); resultobj = Py_None;
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj;
12781 wxImage *arg1 = (wxImage *) 0 ;
12782 unsigned char arg2 ;
12783 unsigned char arg3 ;
12784 unsigned char arg4 ;
12785 SwigValueWrapper<wxImage > result;
12786 PyObject * obj0 = 0 ;
12787 PyObject * obj1 = 0 ;
12788 PyObject * obj2 = 0 ;
12789 PyObject * obj3 = 0 ;
12790 char *kwnames[] = {
12791 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12792 };
12793
12794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12796 if (SWIG_arg_fail(1)) SWIG_fail;
12797 {
12798 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12799 if (SWIG_arg_fail(2)) SWIG_fail;
12800 }
12801 {
12802 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12803 if (SWIG_arg_fail(3)) SWIG_fail;
12804 }
12805 {
12806 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12807 if (SWIG_arg_fail(4)) SWIG_fail;
12808 }
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12812
12813 wxPyEndAllowThreads(__tstate);
12814 if (PyErr_Occurred()) SWIG_fail;
12815 }
12816 {
12817 wxImage * resultptr;
12818 resultptr = new wxImage((wxImage &)(result));
12819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12820 }
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12828 PyObject *resultobj;
12829 wxImage *arg1 = (wxImage *) 0 ;
12830 wxString *arg2 = 0 ;
12831 wxString *arg3 = 0 ;
12832 bool temp2 = false ;
12833 bool temp3 = false ;
12834 PyObject * obj0 = 0 ;
12835 PyObject * obj1 = 0 ;
12836 PyObject * obj2 = 0 ;
12837 char *kwnames[] = {
12838 (char *) "self",(char *) "name",(char *) "value", NULL
12839 };
12840
12841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12843 if (SWIG_arg_fail(1)) SWIG_fail;
12844 {
12845 arg2 = wxString_in_helper(obj1);
12846 if (arg2 == NULL) SWIG_fail;
12847 temp2 = true;
12848 }
12849 {
12850 arg3 = wxString_in_helper(obj2);
12851 if (arg3 == NULL) SWIG_fail;
12852 temp3 = true;
12853 }
12854 {
12855 PyThreadState* __tstate = wxPyBeginAllowThreads();
12856 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12857
12858 wxPyEndAllowThreads(__tstate);
12859 if (PyErr_Occurred()) SWIG_fail;
12860 }
12861 Py_INCREF(Py_None); resultobj = Py_None;
12862 {
12863 if (temp2)
12864 delete arg2;
12865 }
12866 {
12867 if (temp3)
12868 delete arg3;
12869 }
12870 return resultobj;
12871 fail:
12872 {
12873 if (temp2)
12874 delete arg2;
12875 }
12876 {
12877 if (temp3)
12878 delete arg3;
12879 }
12880 return NULL;
12881 }
12882
12883
12884 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12885 PyObject *resultobj;
12886 wxImage *arg1 = (wxImage *) 0 ;
12887 wxString *arg2 = 0 ;
12888 int arg3 ;
12889 bool temp2 = false ;
12890 PyObject * obj0 = 0 ;
12891 PyObject * obj1 = 0 ;
12892 PyObject * obj2 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self",(char *) "name",(char *) "value", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12899 if (SWIG_arg_fail(1)) SWIG_fail;
12900 {
12901 arg2 = wxString_in_helper(obj1);
12902 if (arg2 == NULL) SWIG_fail;
12903 temp2 = true;
12904 }
12905 {
12906 arg3 = (int)(SWIG_As_int(obj2));
12907 if (SWIG_arg_fail(3)) SWIG_fail;
12908 }
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 (arg1)->SetOption((wxString const &)*arg2,arg3);
12912
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 Py_INCREF(Py_None); resultobj = Py_None;
12917 {
12918 if (temp2)
12919 delete arg2;
12920 }
12921 return resultobj;
12922 fail:
12923 {
12924 if (temp2)
12925 delete arg2;
12926 }
12927 return NULL;
12928 }
12929
12930
12931 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12932 PyObject *resultobj;
12933 wxImage *arg1 = (wxImage *) 0 ;
12934 wxString *arg2 = 0 ;
12935 wxString result;
12936 bool temp2 = false ;
12937 PyObject * obj0 = 0 ;
12938 PyObject * obj1 = 0 ;
12939 char *kwnames[] = {
12940 (char *) "self",(char *) "name", NULL
12941 };
12942
12943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12945 if (SWIG_arg_fail(1)) SWIG_fail;
12946 {
12947 arg2 = wxString_in_helper(obj1);
12948 if (arg2 == NULL) SWIG_fail;
12949 temp2 = true;
12950 }
12951 {
12952 PyThreadState* __tstate = wxPyBeginAllowThreads();
12953 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12954
12955 wxPyEndAllowThreads(__tstate);
12956 if (PyErr_Occurred()) SWIG_fail;
12957 }
12958 {
12959 #if wxUSE_UNICODE
12960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12961 #else
12962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12963 #endif
12964 }
12965 {
12966 if (temp2)
12967 delete arg2;
12968 }
12969 return resultobj;
12970 fail:
12971 {
12972 if (temp2)
12973 delete arg2;
12974 }
12975 return NULL;
12976 }
12977
12978
12979 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj;
12981 wxImage *arg1 = (wxImage *) 0 ;
12982 wxString *arg2 = 0 ;
12983 int result;
12984 bool temp2 = false ;
12985 PyObject * obj0 = 0 ;
12986 PyObject * obj1 = 0 ;
12987 char *kwnames[] = {
12988 (char *) "self",(char *) "name", NULL
12989 };
12990
12991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12993 if (SWIG_arg_fail(1)) SWIG_fail;
12994 {
12995 arg2 = wxString_in_helper(obj1);
12996 if (arg2 == NULL) SWIG_fail;
12997 temp2 = true;
12998 }
12999 {
13000 PyThreadState* __tstate = wxPyBeginAllowThreads();
13001 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13002
13003 wxPyEndAllowThreads(__tstate);
13004 if (PyErr_Occurred()) SWIG_fail;
13005 }
13006 {
13007 resultobj = SWIG_From_int((int)(result));
13008 }
13009 {
13010 if (temp2)
13011 delete arg2;
13012 }
13013 return resultobj;
13014 fail:
13015 {
13016 if (temp2)
13017 delete arg2;
13018 }
13019 return NULL;
13020 }
13021
13022
13023 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13024 PyObject *resultobj;
13025 wxImage *arg1 = (wxImage *) 0 ;
13026 wxString *arg2 = 0 ;
13027 bool result;
13028 bool temp2 = false ;
13029 PyObject * obj0 = 0 ;
13030 PyObject * obj1 = 0 ;
13031 char *kwnames[] = {
13032 (char *) "self",(char *) "name", NULL
13033 };
13034
13035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13037 if (SWIG_arg_fail(1)) SWIG_fail;
13038 {
13039 arg2 = wxString_in_helper(obj1);
13040 if (arg2 == NULL) SWIG_fail;
13041 temp2 = true;
13042 }
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 {
13051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13052 }
13053 {
13054 if (temp2)
13055 delete arg2;
13056 }
13057 return resultobj;
13058 fail:
13059 {
13060 if (temp2)
13061 delete arg2;
13062 }
13063 return NULL;
13064 }
13065
13066
13067 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj;
13069 wxImage *arg1 = (wxImage *) 0 ;
13070 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13071 unsigned long result;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "stopafter", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 if (obj1) {
13082 {
13083 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13084 if (SWIG_arg_fail(2)) SWIG_fail;
13085 }
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 result = (unsigned long)(arg1)->CountColours(arg2);
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 {
13095 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13096 }
13097 return resultobj;
13098 fail:
13099 return NULL;
13100 }
13101
13102
13103 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13104 PyObject *resultobj;
13105 wxImage *arg1 = (wxImage *) 0 ;
13106 wxImageHistogram *arg2 = 0 ;
13107 unsigned long result;
13108 PyObject * obj0 = 0 ;
13109 PyObject * obj1 = 0 ;
13110 char *kwnames[] = {
13111 (char *) "self",(char *) "h", NULL
13112 };
13113
13114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13116 if (SWIG_arg_fail(1)) SWIG_fail;
13117 {
13118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13119 if (SWIG_arg_fail(2)) SWIG_fail;
13120 if (arg2 == NULL) {
13121 SWIG_null_ref("wxImageHistogram");
13122 }
13123 if (SWIG_arg_fail(2)) SWIG_fail;
13124 }
13125 {
13126 PyThreadState* __tstate = wxPyBeginAllowThreads();
13127 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13128
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 {
13133 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13134 }
13135 return resultobj;
13136 fail:
13137 return NULL;
13138 }
13139
13140
13141 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13142 PyObject *resultobj;
13143 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13144 PyObject * obj0 = 0 ;
13145 char *kwnames[] = {
13146 (char *) "handler", NULL
13147 };
13148
13149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13151 if (SWIG_arg_fail(1)) SWIG_fail;
13152 {
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 wxImage::AddHandler(arg1);
13155
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 Py_INCREF(Py_None); resultobj = Py_None;
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13167 PyObject *resultobj;
13168 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13169 PyObject * obj0 = 0 ;
13170 char *kwnames[] = {
13171 (char *) "handler", NULL
13172 };
13173
13174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13176 if (SWIG_arg_fail(1)) SWIG_fail;
13177 {
13178 PyThreadState* __tstate = wxPyBeginAllowThreads();
13179 wxImage::InsertHandler(arg1);
13180
13181 wxPyEndAllowThreads(__tstate);
13182 if (PyErr_Occurred()) SWIG_fail;
13183 }
13184 Py_INCREF(Py_None); resultobj = Py_None;
13185 return resultobj;
13186 fail:
13187 return NULL;
13188 }
13189
13190
13191 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13192 PyObject *resultobj;
13193 wxString *arg1 = 0 ;
13194 bool result;
13195 bool temp1 = false ;
13196 PyObject * obj0 = 0 ;
13197 char *kwnames[] = {
13198 (char *) "name", NULL
13199 };
13200
13201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13202 {
13203 arg1 = wxString_in_helper(obj0);
13204 if (arg1 == NULL) SWIG_fail;
13205 temp1 = true;
13206 }
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13210
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 {
13215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13216 }
13217 {
13218 if (temp1)
13219 delete arg1;
13220 }
13221 return resultobj;
13222 fail:
13223 {
13224 if (temp1)
13225 delete arg1;
13226 }
13227 return NULL;
13228 }
13229
13230
13231 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13232 PyObject *resultobj;
13233 wxString result;
13234 char *kwnames[] = {
13235 NULL
13236 };
13237
13238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 result = wxImage::GetImageExtWildcard();
13242
13243 wxPyEndAllowThreads(__tstate);
13244 if (PyErr_Occurred()) SWIG_fail;
13245 }
13246 {
13247 #if wxUSE_UNICODE
13248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13249 #else
13250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13251 #endif
13252 }
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj;
13261 wxImage *arg1 = (wxImage *) 0 ;
13262 int arg2 = (int) -1 ;
13263 wxBitmap result;
13264 PyObject * obj0 = 0 ;
13265 PyObject * obj1 = 0 ;
13266 char *kwnames[] = {
13267 (char *) "self",(char *) "depth", NULL
13268 };
13269
13270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13272 if (SWIG_arg_fail(1)) SWIG_fail;
13273 if (obj1) {
13274 {
13275 arg2 = (int)(SWIG_As_int(obj1));
13276 if (SWIG_arg_fail(2)) SWIG_fail;
13277 }
13278 }
13279 {
13280 if (!wxPyCheckForApp()) SWIG_fail;
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 result = wxImage_ConvertToBitmap(arg1,arg2);
13283
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 {
13288 wxBitmap * resultptr;
13289 resultptr = new wxBitmap((wxBitmap &)(result));
13290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13291 }
13292 return resultobj;
13293 fail:
13294 return NULL;
13295 }
13296
13297
13298 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13299 PyObject *resultobj;
13300 wxImage *arg1 = (wxImage *) 0 ;
13301 unsigned char arg2 ;
13302 unsigned char arg3 ;
13303 unsigned char arg4 ;
13304 wxBitmap result;
13305 PyObject * obj0 = 0 ;
13306 PyObject * obj1 = 0 ;
13307 PyObject * obj2 = 0 ;
13308 PyObject * obj3 = 0 ;
13309 char *kwnames[] = {
13310 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13311 };
13312
13313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13315 if (SWIG_arg_fail(1)) SWIG_fail;
13316 {
13317 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13318 if (SWIG_arg_fail(2)) SWIG_fail;
13319 }
13320 {
13321 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13322 if (SWIG_arg_fail(3)) SWIG_fail;
13323 }
13324 {
13325 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13326 if (SWIG_arg_fail(4)) SWIG_fail;
13327 }
13328 {
13329 if (!wxPyCheckForApp()) SWIG_fail;
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13332
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 {
13337 wxBitmap * resultptr;
13338 resultptr = new wxBitmap((wxBitmap &)(result));
13339 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13340 }
13341 return resultobj;
13342 fail:
13343 return NULL;
13344 }
13345
13346
13347 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13348 PyObject *obj;
13349 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13350 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13351 Py_INCREF(obj);
13352 return Py_BuildValue((char *)"");
13353 }
13354 static int _wrap_NullImage_set(PyObject *) {
13355 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13356 return 1;
13357 }
13358
13359
13360 static PyObject *_wrap_NullImage_get(void) {
13361 PyObject *pyobj;
13362
13363 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13364 return pyobj;
13365 }
13366
13367
13368 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13369 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13370 return 1;
13371 }
13372
13373
13374 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13375 PyObject *pyobj;
13376
13377 {
13378 #if wxUSE_UNICODE
13379 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13380 #else
13381 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13382 #endif
13383 }
13384 return pyobj;
13385 }
13386
13387
13388 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13389 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13390 return 1;
13391 }
13392
13393
13394 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13395 PyObject *pyobj;
13396
13397 {
13398 #if wxUSE_UNICODE
13399 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13400 #else
13401 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13402 #endif
13403 }
13404 return pyobj;
13405 }
13406
13407
13408 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13409 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13410 return 1;
13411 }
13412
13413
13414 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13415 PyObject *pyobj;
13416
13417 {
13418 #if wxUSE_UNICODE
13419 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13420 #else
13421 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13422 #endif
13423 }
13424 return pyobj;
13425 }
13426
13427
13428 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13429 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13430 return 1;
13431 }
13432
13433
13434 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13435 PyObject *pyobj;
13436
13437 {
13438 #if wxUSE_UNICODE
13439 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13440 #else
13441 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13442 #endif
13443 }
13444 return pyobj;
13445 }
13446
13447
13448 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13449 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13450 return 1;
13451 }
13452
13453
13454 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13455 PyObject *pyobj;
13456
13457 {
13458 #if wxUSE_UNICODE
13459 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13460 #else
13461 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13462 #endif
13463 }
13464 return pyobj;
13465 }
13466
13467
13468 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13469 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13470 return 1;
13471 }
13472
13473
13474 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13475 PyObject *pyobj;
13476
13477 {
13478 #if wxUSE_UNICODE
13479 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13480 #else
13481 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13482 #endif
13483 }
13484 return pyobj;
13485 }
13486
13487
13488 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13489 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13490 return 1;
13491 }
13492
13493
13494 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13495 PyObject *pyobj;
13496
13497 {
13498 #if wxUSE_UNICODE
13499 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13500 #else
13501 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13502 #endif
13503 }
13504 return pyobj;
13505 }
13506
13507
13508 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13509 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13510 return 1;
13511 }
13512
13513
13514 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13515 PyObject *pyobj;
13516
13517 {
13518 #if wxUSE_UNICODE
13519 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13520 #else
13521 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13522 #endif
13523 }
13524 return pyobj;
13525 }
13526
13527
13528 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13529 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13530 return 1;
13531 }
13532
13533
13534 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13535 PyObject *pyobj;
13536
13537 {
13538 #if wxUSE_UNICODE
13539 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13540 #else
13541 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13542 #endif
13543 }
13544 return pyobj;
13545 }
13546
13547
13548 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13549 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13550 return 1;
13551 }
13552
13553
13554 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13555 PyObject *pyobj;
13556
13557 {
13558 #if wxUSE_UNICODE
13559 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13560 #else
13561 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13562 #endif
13563 }
13564 return pyobj;
13565 }
13566
13567
13568 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13569 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13570 return 1;
13571 }
13572
13573
13574 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13575 PyObject *pyobj;
13576
13577 {
13578 #if wxUSE_UNICODE
13579 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13580 #else
13581 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13582 #endif
13583 }
13584 return pyobj;
13585 }
13586
13587
13588 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13589 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13590 return 1;
13591 }
13592
13593
13594 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13595 PyObject *pyobj;
13596
13597 {
13598 #if wxUSE_UNICODE
13599 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13600 #else
13601 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13602 #endif
13603 }
13604 return pyobj;
13605 }
13606
13607
13608 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13609 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13610 return 1;
13611 }
13612
13613
13614 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13615 PyObject *pyobj;
13616
13617 {
13618 #if wxUSE_UNICODE
13619 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13620 #else
13621 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13622 #endif
13623 }
13624 return pyobj;
13625 }
13626
13627
13628 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13629 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13630 return 1;
13631 }
13632
13633
13634 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13635 PyObject *pyobj;
13636
13637 {
13638 #if wxUSE_UNICODE
13639 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13640 #else
13641 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13642 #endif
13643 }
13644 return pyobj;
13645 }
13646
13647
13648 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13649 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13650 return 1;
13651 }
13652
13653
13654 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13655 PyObject *pyobj;
13656
13657 {
13658 #if wxUSE_UNICODE
13659 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13660 #else
13661 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13662 #endif
13663 }
13664 return pyobj;
13665 }
13666
13667
13668 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13669 PyObject *resultobj;
13670 wxBMPHandler *result;
13671 char *kwnames[] = {
13672 NULL
13673 };
13674
13675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 result = (wxBMPHandler *)new wxBMPHandler();
13679
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13684 return resultobj;
13685 fail:
13686 return NULL;
13687 }
13688
13689
13690 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13691 PyObject *obj;
13692 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13693 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13694 Py_INCREF(obj);
13695 return Py_BuildValue((char *)"");
13696 }
13697 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj;
13699 wxICOHandler *result;
13700 char *kwnames[] = {
13701 NULL
13702 };
13703
13704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13705 {
13706 PyThreadState* __tstate = wxPyBeginAllowThreads();
13707 result = (wxICOHandler *)new wxICOHandler();
13708
13709 wxPyEndAllowThreads(__tstate);
13710 if (PyErr_Occurred()) SWIG_fail;
13711 }
13712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13713 return resultobj;
13714 fail:
13715 return NULL;
13716 }
13717
13718
13719 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13720 PyObject *obj;
13721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13722 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13723 Py_INCREF(obj);
13724 return Py_BuildValue((char *)"");
13725 }
13726 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13727 PyObject *resultobj;
13728 wxCURHandler *result;
13729 char *kwnames[] = {
13730 NULL
13731 };
13732
13733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13734 {
13735 PyThreadState* __tstate = wxPyBeginAllowThreads();
13736 result = (wxCURHandler *)new wxCURHandler();
13737
13738 wxPyEndAllowThreads(__tstate);
13739 if (PyErr_Occurred()) SWIG_fail;
13740 }
13741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13742 return resultobj;
13743 fail:
13744 return NULL;
13745 }
13746
13747
13748 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13749 PyObject *obj;
13750 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13751 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13752 Py_INCREF(obj);
13753 return Py_BuildValue((char *)"");
13754 }
13755 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13756 PyObject *resultobj;
13757 wxANIHandler *result;
13758 char *kwnames[] = {
13759 NULL
13760 };
13761
13762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 result = (wxANIHandler *)new wxANIHandler();
13766
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13771 return resultobj;
13772 fail:
13773 return NULL;
13774 }
13775
13776
13777 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13778 PyObject *obj;
13779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13780 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13781 Py_INCREF(obj);
13782 return Py_BuildValue((char *)"");
13783 }
13784 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13785 PyObject *resultobj;
13786 wxPNGHandler *result;
13787 char *kwnames[] = {
13788 NULL
13789 };
13790
13791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13792 {
13793 PyThreadState* __tstate = wxPyBeginAllowThreads();
13794 result = (wxPNGHandler *)new wxPNGHandler();
13795
13796 wxPyEndAllowThreads(__tstate);
13797 if (PyErr_Occurred()) SWIG_fail;
13798 }
13799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13800 return resultobj;
13801 fail:
13802 return NULL;
13803 }
13804
13805
13806 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13807 PyObject *obj;
13808 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13809 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13810 Py_INCREF(obj);
13811 return Py_BuildValue((char *)"");
13812 }
13813 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13814 PyObject *resultobj;
13815 wxGIFHandler *result;
13816 char *kwnames[] = {
13817 NULL
13818 };
13819
13820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13821 {
13822 PyThreadState* __tstate = wxPyBeginAllowThreads();
13823 result = (wxGIFHandler *)new wxGIFHandler();
13824
13825 wxPyEndAllowThreads(__tstate);
13826 if (PyErr_Occurred()) SWIG_fail;
13827 }
13828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13829 return resultobj;
13830 fail:
13831 return NULL;
13832 }
13833
13834
13835 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13836 PyObject *obj;
13837 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13838 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13839 Py_INCREF(obj);
13840 return Py_BuildValue((char *)"");
13841 }
13842 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13843 PyObject *resultobj;
13844 wxPCXHandler *result;
13845 char *kwnames[] = {
13846 NULL
13847 };
13848
13849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13850 {
13851 PyThreadState* __tstate = wxPyBeginAllowThreads();
13852 result = (wxPCXHandler *)new wxPCXHandler();
13853
13854 wxPyEndAllowThreads(__tstate);
13855 if (PyErr_Occurred()) SWIG_fail;
13856 }
13857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13858 return resultobj;
13859 fail:
13860 return NULL;
13861 }
13862
13863
13864 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13865 PyObject *obj;
13866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13867 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13868 Py_INCREF(obj);
13869 return Py_BuildValue((char *)"");
13870 }
13871 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13872 PyObject *resultobj;
13873 wxJPEGHandler *result;
13874 char *kwnames[] = {
13875 NULL
13876 };
13877
13878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13879 {
13880 PyThreadState* __tstate = wxPyBeginAllowThreads();
13881 result = (wxJPEGHandler *)new wxJPEGHandler();
13882
13883 wxPyEndAllowThreads(__tstate);
13884 if (PyErr_Occurred()) SWIG_fail;
13885 }
13886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13887 return resultobj;
13888 fail:
13889 return NULL;
13890 }
13891
13892
13893 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13894 PyObject *obj;
13895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13896 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13897 Py_INCREF(obj);
13898 return Py_BuildValue((char *)"");
13899 }
13900 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13901 PyObject *resultobj;
13902 wxPNMHandler *result;
13903 char *kwnames[] = {
13904 NULL
13905 };
13906
13907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 result = (wxPNMHandler *)new wxPNMHandler();
13911
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13923 PyObject *obj;
13924 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13925 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13926 Py_INCREF(obj);
13927 return Py_BuildValue((char *)"");
13928 }
13929 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13930 PyObject *resultobj;
13931 wxXPMHandler *result;
13932 char *kwnames[] = {
13933 NULL
13934 };
13935
13936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13937 {
13938 PyThreadState* __tstate = wxPyBeginAllowThreads();
13939 result = (wxXPMHandler *)new wxXPMHandler();
13940
13941 wxPyEndAllowThreads(__tstate);
13942 if (PyErr_Occurred()) SWIG_fail;
13943 }
13944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13945 return resultobj;
13946 fail:
13947 return NULL;
13948 }
13949
13950
13951 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13952 PyObject *obj;
13953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13954 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13955 Py_INCREF(obj);
13956 return Py_BuildValue((char *)"");
13957 }
13958 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13959 PyObject *resultobj;
13960 wxTIFFHandler *result;
13961 char *kwnames[] = {
13962 NULL
13963 };
13964
13965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 result = (wxTIFFHandler *)new wxTIFFHandler();
13969
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13974 return resultobj;
13975 fail:
13976 return NULL;
13977 }
13978
13979
13980 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13981 PyObject *obj;
13982 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13983 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13984 Py_INCREF(obj);
13985 return Py_BuildValue((char *)"");
13986 }
13987 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13988 PyObject *resultobj;
13989 wxImage *arg1 = 0 ;
13990 wxImage *arg2 = 0 ;
13991 int arg3 = (int) 236 ;
13992 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13993 bool result;
13994 PyObject * obj0 = 0 ;
13995 PyObject * obj1 = 0 ;
13996 PyObject * obj2 = 0 ;
13997 PyObject * obj3 = 0 ;
13998 char *kwnames[] = {
13999 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14000 };
14001
14002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14003 {
14004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14005 if (SWIG_arg_fail(1)) SWIG_fail;
14006 if (arg1 == NULL) {
14007 SWIG_null_ref("wxImage");
14008 }
14009 if (SWIG_arg_fail(1)) SWIG_fail;
14010 }
14011 {
14012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14013 if (SWIG_arg_fail(2)) SWIG_fail;
14014 if (arg2 == NULL) {
14015 SWIG_null_ref("wxImage");
14016 }
14017 if (SWIG_arg_fail(2)) SWIG_fail;
14018 }
14019 if (obj2) {
14020 {
14021 arg3 = (int)(SWIG_As_int(obj2));
14022 if (SWIG_arg_fail(3)) SWIG_fail;
14023 }
14024 }
14025 if (obj3) {
14026 {
14027 arg4 = (int)(SWIG_As_int(obj3));
14028 if (SWIG_arg_fail(4)) SWIG_fail;
14029 }
14030 }
14031 {
14032 PyThreadState* __tstate = wxPyBeginAllowThreads();
14033 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14034
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 {
14039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14040 }
14041 return resultobj;
14042 fail:
14043 return NULL;
14044 }
14045
14046
14047 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14048 PyObject *obj;
14049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14050 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14051 Py_INCREF(obj);
14052 return Py_BuildValue((char *)"");
14053 }
14054 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14055 PyObject *resultobj;
14056 wxEvtHandler *result;
14057 char *kwnames[] = {
14058 NULL
14059 };
14060
14061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14062 {
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 result = (wxEvtHandler *)new wxEvtHandler();
14065
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj;
14078 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14079 wxEvtHandler *result;
14080 PyObject * obj0 = 0 ;
14081 char *kwnames[] = {
14082 (char *) "self", NULL
14083 };
14084
14085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14087 if (SWIG_arg_fail(1)) SWIG_fail;
14088 {
14089 PyThreadState* __tstate = wxPyBeginAllowThreads();
14090 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14091
14092 wxPyEndAllowThreads(__tstate);
14093 if (PyErr_Occurred()) SWIG_fail;
14094 }
14095 {
14096 resultobj = wxPyMake_wxObject(result, 0);
14097 }
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14105 PyObject *resultobj;
14106 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14107 wxEvtHandler *result;
14108 PyObject * obj0 = 0 ;
14109 char *kwnames[] = {
14110 (char *) "self", NULL
14111 };
14112
14113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14115 if (SWIG_arg_fail(1)) SWIG_fail;
14116 {
14117 PyThreadState* __tstate = wxPyBeginAllowThreads();
14118 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14119
14120 wxPyEndAllowThreads(__tstate);
14121 if (PyErr_Occurred()) SWIG_fail;
14122 }
14123 {
14124 resultobj = wxPyMake_wxObject(result, 0);
14125 }
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14133 PyObject *resultobj;
14134 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14135 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14136 PyObject * obj0 = 0 ;
14137 PyObject * obj1 = 0 ;
14138 char *kwnames[] = {
14139 (char *) "self",(char *) "handler", NULL
14140 };
14141
14142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14144 if (SWIG_arg_fail(1)) SWIG_fail;
14145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14146 if (SWIG_arg_fail(2)) SWIG_fail;
14147 {
14148 PyThreadState* __tstate = wxPyBeginAllowThreads();
14149 (arg1)->SetNextHandler(arg2);
14150
14151 wxPyEndAllowThreads(__tstate);
14152 if (PyErr_Occurred()) SWIG_fail;
14153 }
14154 Py_INCREF(Py_None); resultobj = Py_None;
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj;
14163 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14164 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14165 PyObject * obj0 = 0 ;
14166 PyObject * obj1 = 0 ;
14167 char *kwnames[] = {
14168 (char *) "self",(char *) "handler", NULL
14169 };
14170
14171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14173 if (SWIG_arg_fail(1)) SWIG_fail;
14174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14175 if (SWIG_arg_fail(2)) SWIG_fail;
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 (arg1)->SetPreviousHandler(arg2);
14179
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 Py_INCREF(Py_None); resultobj = Py_None;
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14191 PyObject *resultobj;
14192 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14193 bool result;
14194 PyObject * obj0 = 0 ;
14195 char *kwnames[] = {
14196 (char *) "self", NULL
14197 };
14198
14199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14201 if (SWIG_arg_fail(1)) SWIG_fail;
14202 {
14203 PyThreadState* __tstate = wxPyBeginAllowThreads();
14204 result = (bool)(arg1)->GetEvtHandlerEnabled();
14205
14206 wxPyEndAllowThreads(__tstate);
14207 if (PyErr_Occurred()) SWIG_fail;
14208 }
14209 {
14210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14211 }
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14219 PyObject *resultobj;
14220 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14221 bool arg2 ;
14222 PyObject * obj0 = 0 ;
14223 PyObject * obj1 = 0 ;
14224 char *kwnames[] = {
14225 (char *) "self",(char *) "enabled", NULL
14226 };
14227
14228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14230 if (SWIG_arg_fail(1)) SWIG_fail;
14231 {
14232 arg2 = (bool)(SWIG_As_bool(obj1));
14233 if (SWIG_arg_fail(2)) SWIG_fail;
14234 }
14235 {
14236 PyThreadState* __tstate = wxPyBeginAllowThreads();
14237 (arg1)->SetEvtHandlerEnabled(arg2);
14238
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 Py_INCREF(Py_None); resultobj = Py_None;
14243 return resultobj;
14244 fail:
14245 return NULL;
14246 }
14247
14248
14249 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14250 PyObject *resultobj;
14251 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14252 wxEvent *arg2 = 0 ;
14253 bool result;
14254 PyObject * obj0 = 0 ;
14255 PyObject * obj1 = 0 ;
14256 char *kwnames[] = {
14257 (char *) "self",(char *) "event", NULL
14258 };
14259
14260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14262 if (SWIG_arg_fail(1)) SWIG_fail;
14263 {
14264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14265 if (SWIG_arg_fail(2)) SWIG_fail;
14266 if (arg2 == NULL) {
14267 SWIG_null_ref("wxEvent");
14268 }
14269 if (SWIG_arg_fail(2)) SWIG_fail;
14270 }
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 result = (bool)(arg1)->ProcessEvent(*arg2);
14274
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 {
14279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14280 }
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj;
14289 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14290 wxEvent *arg2 = 0 ;
14291 PyObject * obj0 = 0 ;
14292 PyObject * obj1 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self",(char *) "event", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14302 if (SWIG_arg_fail(2)) SWIG_fail;
14303 if (arg2 == NULL) {
14304 SWIG_null_ref("wxEvent");
14305 }
14306 if (SWIG_arg_fail(2)) SWIG_fail;
14307 }
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 (arg1)->AddPendingEvent(*arg2);
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 Py_INCREF(Py_None); resultobj = Py_None;
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj;
14324 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14325 PyObject * obj0 = 0 ;
14326 char *kwnames[] = {
14327 (char *) "self", NULL
14328 };
14329
14330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14332 if (SWIG_arg_fail(1)) SWIG_fail;
14333 {
14334 PyThreadState* __tstate = wxPyBeginAllowThreads();
14335 (arg1)->ProcessPendingEvents();
14336
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 Py_INCREF(Py_None); resultobj = Py_None;
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj;
14349 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14350 int arg2 ;
14351 int arg3 ;
14352 int arg4 ;
14353 PyObject *arg5 = (PyObject *) 0 ;
14354 PyObject * obj0 = 0 ;
14355 PyObject * obj1 = 0 ;
14356 PyObject * obj2 = 0 ;
14357 PyObject * obj3 = 0 ;
14358 PyObject * obj4 = 0 ;
14359 char *kwnames[] = {
14360 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14361 };
14362
14363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14365 if (SWIG_arg_fail(1)) SWIG_fail;
14366 {
14367 arg2 = (int)(SWIG_As_int(obj1));
14368 if (SWIG_arg_fail(2)) SWIG_fail;
14369 }
14370 {
14371 arg3 = (int)(SWIG_As_int(obj2));
14372 if (SWIG_arg_fail(3)) SWIG_fail;
14373 }
14374 {
14375 arg4 = (int)(SWIG_As_int(obj3));
14376 if (SWIG_arg_fail(4)) SWIG_fail;
14377 }
14378 arg5 = obj4;
14379 {
14380 PyThreadState* __tstate = wxPyBeginAllowThreads();
14381 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14382
14383 wxPyEndAllowThreads(__tstate);
14384 if (PyErr_Occurred()) SWIG_fail;
14385 }
14386 Py_INCREF(Py_None); resultobj = Py_None;
14387 return resultobj;
14388 fail:
14389 return NULL;
14390 }
14391
14392
14393 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14394 PyObject *resultobj;
14395 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14396 int arg2 ;
14397 int arg3 = (int) -1 ;
14398 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14399 bool result;
14400 PyObject * obj0 = 0 ;
14401 PyObject * obj1 = 0 ;
14402 PyObject * obj2 = 0 ;
14403 PyObject * obj3 = 0 ;
14404 char *kwnames[] = {
14405 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14406 };
14407
14408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14410 if (SWIG_arg_fail(1)) SWIG_fail;
14411 {
14412 arg2 = (int)(SWIG_As_int(obj1));
14413 if (SWIG_arg_fail(2)) SWIG_fail;
14414 }
14415 if (obj2) {
14416 {
14417 arg3 = (int)(SWIG_As_int(obj2));
14418 if (SWIG_arg_fail(3)) SWIG_fail;
14419 }
14420 }
14421 if (obj3) {
14422 {
14423 arg4 = (wxEventType)(SWIG_As_int(obj3));
14424 if (SWIG_arg_fail(4)) SWIG_fail;
14425 }
14426 }
14427 {
14428 PyThreadState* __tstate = wxPyBeginAllowThreads();
14429 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14430
14431 wxPyEndAllowThreads(__tstate);
14432 if (PyErr_Occurred()) SWIG_fail;
14433 }
14434 {
14435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14436 }
14437 return resultobj;
14438 fail:
14439 return NULL;
14440 }
14441
14442
14443 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14444 PyObject *resultobj;
14445 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14446 PyObject *arg2 = (PyObject *) 0 ;
14447 bool arg3 = (bool) true ;
14448 PyObject * obj0 = 0 ;
14449 PyObject * obj1 = 0 ;
14450 PyObject * obj2 = 0 ;
14451 char *kwnames[] = {
14452 (char *) "self",(char *) "_self",(char *) "incref", NULL
14453 };
14454
14455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14457 if (SWIG_arg_fail(1)) SWIG_fail;
14458 arg2 = obj1;
14459 if (obj2) {
14460 {
14461 arg3 = (bool)(SWIG_As_bool(obj2));
14462 if (SWIG_arg_fail(3)) SWIG_fail;
14463 }
14464 }
14465 {
14466 PyThreadState* __tstate = wxPyBeginAllowThreads();
14467 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14468
14469 wxPyEndAllowThreads(__tstate);
14470 if (PyErr_Occurred()) SWIG_fail;
14471 }
14472 Py_INCREF(Py_None); resultobj = Py_None;
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14480 PyObject *obj;
14481 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14482 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14483 Py_INCREF(obj);
14484 return Py_BuildValue((char *)"");
14485 }
14486 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14487 PyObject *resultobj;
14488 wxEventType result;
14489 char *kwnames[] = {
14490 NULL
14491 };
14492
14493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14494 {
14495 PyThreadState* __tstate = wxPyBeginAllowThreads();
14496 result = (wxEventType)wxNewEventType();
14497
14498 wxPyEndAllowThreads(__tstate);
14499 if (PyErr_Occurred()) SWIG_fail;
14500 }
14501 {
14502 resultobj = SWIG_From_int((int)(result));
14503 }
14504 return resultobj;
14505 fail:
14506 return NULL;
14507 }
14508
14509
14510 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14511 PyObject *resultobj;
14512 wxEvent *arg1 = (wxEvent *) 0 ;
14513 PyObject * obj0 = 0 ;
14514 char *kwnames[] = {
14515 (char *) "self", NULL
14516 };
14517
14518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14520 if (SWIG_arg_fail(1)) SWIG_fail;
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 delete arg1;
14524
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 Py_INCREF(Py_None); resultobj = Py_None;
14529 return resultobj;
14530 fail:
14531 return NULL;
14532 }
14533
14534
14535 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj;
14537 wxEvent *arg1 = (wxEvent *) 0 ;
14538 wxEventType arg2 ;
14539 PyObject * obj0 = 0 ;
14540 PyObject * obj1 = 0 ;
14541 char *kwnames[] = {
14542 (char *) "self",(char *) "typ", NULL
14543 };
14544
14545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14547 if (SWIG_arg_fail(1)) SWIG_fail;
14548 {
14549 arg2 = (wxEventType)(SWIG_As_int(obj1));
14550 if (SWIG_arg_fail(2)) SWIG_fail;
14551 }
14552 {
14553 PyThreadState* __tstate = wxPyBeginAllowThreads();
14554 (arg1)->SetEventType(arg2);
14555
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 Py_INCREF(Py_None); resultobj = Py_None;
14560 return resultobj;
14561 fail:
14562 return NULL;
14563 }
14564
14565
14566 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj;
14568 wxEvent *arg1 = (wxEvent *) 0 ;
14569 wxEventType result;
14570 PyObject * obj0 = 0 ;
14571 char *kwnames[] = {
14572 (char *) "self", NULL
14573 };
14574
14575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14577 if (SWIG_arg_fail(1)) SWIG_fail;
14578 {
14579 PyThreadState* __tstate = wxPyBeginAllowThreads();
14580 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14581
14582 wxPyEndAllowThreads(__tstate);
14583 if (PyErr_Occurred()) SWIG_fail;
14584 }
14585 {
14586 resultobj = SWIG_From_int((int)(result));
14587 }
14588 return resultobj;
14589 fail:
14590 return NULL;
14591 }
14592
14593
14594 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14595 PyObject *resultobj;
14596 wxEvent *arg1 = (wxEvent *) 0 ;
14597 wxObject *result;
14598 PyObject * obj0 = 0 ;
14599 char *kwnames[] = {
14600 (char *) "self", NULL
14601 };
14602
14603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14605 if (SWIG_arg_fail(1)) SWIG_fail;
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14609
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 {
14614 resultobj = wxPyMake_wxObject(result, 0);
14615 }
14616 return resultobj;
14617 fail:
14618 return NULL;
14619 }
14620
14621
14622 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14623 PyObject *resultobj;
14624 wxEvent *arg1 = (wxEvent *) 0 ;
14625 wxObject *arg2 = (wxObject *) 0 ;
14626 PyObject * obj0 = 0 ;
14627 PyObject * obj1 = 0 ;
14628 char *kwnames[] = {
14629 (char *) "self",(char *) "obj", NULL
14630 };
14631
14632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14634 if (SWIG_arg_fail(1)) SWIG_fail;
14635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14636 if (SWIG_arg_fail(2)) SWIG_fail;
14637 {
14638 PyThreadState* __tstate = wxPyBeginAllowThreads();
14639 (arg1)->SetEventObject(arg2);
14640
14641 wxPyEndAllowThreads(__tstate);
14642 if (PyErr_Occurred()) SWIG_fail;
14643 }
14644 Py_INCREF(Py_None); resultobj = Py_None;
14645 return resultobj;
14646 fail:
14647 return NULL;
14648 }
14649
14650
14651 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14652 PyObject *resultobj;
14653 wxEvent *arg1 = (wxEvent *) 0 ;
14654 long result;
14655 PyObject * obj0 = 0 ;
14656 char *kwnames[] = {
14657 (char *) "self", NULL
14658 };
14659
14660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14662 if (SWIG_arg_fail(1)) SWIG_fail;
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14666
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 {
14671 resultobj = SWIG_From_long((long)(result));
14672 }
14673 return resultobj;
14674 fail:
14675 return NULL;
14676 }
14677
14678
14679 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14680 PyObject *resultobj;
14681 wxEvent *arg1 = (wxEvent *) 0 ;
14682 long arg2 = (long) 0 ;
14683 PyObject * obj0 = 0 ;
14684 PyObject * obj1 = 0 ;
14685 char *kwnames[] = {
14686 (char *) "self",(char *) "ts", NULL
14687 };
14688
14689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14691 if (SWIG_arg_fail(1)) SWIG_fail;
14692 if (obj1) {
14693 {
14694 arg2 = (long)(SWIG_As_long(obj1));
14695 if (SWIG_arg_fail(2)) SWIG_fail;
14696 }
14697 }
14698 {
14699 PyThreadState* __tstate = wxPyBeginAllowThreads();
14700 (arg1)->SetTimestamp(arg2);
14701
14702 wxPyEndAllowThreads(__tstate);
14703 if (PyErr_Occurred()) SWIG_fail;
14704 }
14705 Py_INCREF(Py_None); resultobj = Py_None;
14706 return resultobj;
14707 fail:
14708 return NULL;
14709 }
14710
14711
14712 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14713 PyObject *resultobj;
14714 wxEvent *arg1 = (wxEvent *) 0 ;
14715 int result;
14716 PyObject * obj0 = 0 ;
14717 char *kwnames[] = {
14718 (char *) "self", NULL
14719 };
14720
14721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14723 if (SWIG_arg_fail(1)) SWIG_fail;
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (int)((wxEvent const *)arg1)->GetId();
14727
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 {
14732 resultobj = SWIG_From_int((int)(result));
14733 }
14734 return resultobj;
14735 fail:
14736 return NULL;
14737 }
14738
14739
14740 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14741 PyObject *resultobj;
14742 wxEvent *arg1 = (wxEvent *) 0 ;
14743 int arg2 ;
14744 PyObject * obj0 = 0 ;
14745 PyObject * obj1 = 0 ;
14746 char *kwnames[] = {
14747 (char *) "self",(char *) "Id", NULL
14748 };
14749
14750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(1)) SWIG_fail;
14753 {
14754 arg2 = (int)(SWIG_As_int(obj1));
14755 if (SWIG_arg_fail(2)) SWIG_fail;
14756 }
14757 {
14758 PyThreadState* __tstate = wxPyBeginAllowThreads();
14759 (arg1)->SetId(arg2);
14760
14761 wxPyEndAllowThreads(__tstate);
14762 if (PyErr_Occurred()) SWIG_fail;
14763 }
14764 Py_INCREF(Py_None); resultobj = Py_None;
14765 return resultobj;
14766 fail:
14767 return NULL;
14768 }
14769
14770
14771 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14772 PyObject *resultobj;
14773 wxEvent *arg1 = (wxEvent *) 0 ;
14774 bool result;
14775 PyObject * obj0 = 0 ;
14776 char *kwnames[] = {
14777 (char *) "self", NULL
14778 };
14779
14780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14782 if (SWIG_arg_fail(1)) SWIG_fail;
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14786
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 {
14791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14792 }
14793 return resultobj;
14794 fail:
14795 return NULL;
14796 }
14797
14798
14799 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14800 PyObject *resultobj;
14801 wxEvent *arg1 = (wxEvent *) 0 ;
14802 bool arg2 = (bool) true ;
14803 PyObject * obj0 = 0 ;
14804 PyObject * obj1 = 0 ;
14805 char *kwnames[] = {
14806 (char *) "self",(char *) "skip", NULL
14807 };
14808
14809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14811 if (SWIG_arg_fail(1)) SWIG_fail;
14812 if (obj1) {
14813 {
14814 arg2 = (bool)(SWIG_As_bool(obj1));
14815 if (SWIG_arg_fail(2)) SWIG_fail;
14816 }
14817 }
14818 {
14819 PyThreadState* __tstate = wxPyBeginAllowThreads();
14820 (arg1)->Skip(arg2);
14821
14822 wxPyEndAllowThreads(__tstate);
14823 if (PyErr_Occurred()) SWIG_fail;
14824 }
14825 Py_INCREF(Py_None); resultobj = Py_None;
14826 return resultobj;
14827 fail:
14828 return NULL;
14829 }
14830
14831
14832 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14833 PyObject *resultobj;
14834 wxEvent *arg1 = (wxEvent *) 0 ;
14835 bool result;
14836 PyObject * obj0 = 0 ;
14837 char *kwnames[] = {
14838 (char *) "self", NULL
14839 };
14840
14841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14843 if (SWIG_arg_fail(1)) SWIG_fail;
14844 {
14845 PyThreadState* __tstate = wxPyBeginAllowThreads();
14846 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14847
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 {
14852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14853 }
14854 return resultobj;
14855 fail:
14856 return NULL;
14857 }
14858
14859
14860 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj;
14862 wxEvent *arg1 = (wxEvent *) 0 ;
14863 bool result;
14864 PyObject * obj0 = 0 ;
14865 char *kwnames[] = {
14866 (char *) "self", NULL
14867 };
14868
14869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14871 if (SWIG_arg_fail(1)) SWIG_fail;
14872 {
14873 PyThreadState* __tstate = wxPyBeginAllowThreads();
14874 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14875
14876 wxPyEndAllowThreads(__tstate);
14877 if (PyErr_Occurred()) SWIG_fail;
14878 }
14879 {
14880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14881 }
14882 return resultobj;
14883 fail:
14884 return NULL;
14885 }
14886
14887
14888 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14889 PyObject *resultobj;
14890 wxEvent *arg1 = (wxEvent *) 0 ;
14891 int result;
14892 PyObject * obj0 = 0 ;
14893 char *kwnames[] = {
14894 (char *) "self", NULL
14895 };
14896
14897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14899 if (SWIG_arg_fail(1)) SWIG_fail;
14900 {
14901 PyThreadState* __tstate = wxPyBeginAllowThreads();
14902 result = (int)(arg1)->StopPropagation();
14903
14904 wxPyEndAllowThreads(__tstate);
14905 if (PyErr_Occurred()) SWIG_fail;
14906 }
14907 {
14908 resultobj = SWIG_From_int((int)(result));
14909 }
14910 return resultobj;
14911 fail:
14912 return NULL;
14913 }
14914
14915
14916 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14917 PyObject *resultobj;
14918 wxEvent *arg1 = (wxEvent *) 0 ;
14919 int arg2 ;
14920 PyObject * obj0 = 0 ;
14921 PyObject * obj1 = 0 ;
14922 char *kwnames[] = {
14923 (char *) "self",(char *) "propagationLevel", NULL
14924 };
14925
14926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14928 if (SWIG_arg_fail(1)) SWIG_fail;
14929 {
14930 arg2 = (int)(SWIG_As_int(obj1));
14931 if (SWIG_arg_fail(2)) SWIG_fail;
14932 }
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 (arg1)->ResumePropagation(arg2);
14936
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 Py_INCREF(Py_None); resultobj = Py_None;
14941 return resultobj;
14942 fail:
14943 return NULL;
14944 }
14945
14946
14947 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14948 PyObject *resultobj;
14949 wxEvent *arg1 = (wxEvent *) 0 ;
14950 wxEvent *result;
14951 PyObject * obj0 = 0 ;
14952 char *kwnames[] = {
14953 (char *) "self", NULL
14954 };
14955
14956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14958 if (SWIG_arg_fail(1)) SWIG_fail;
14959 {
14960 PyThreadState* __tstate = wxPyBeginAllowThreads();
14961 result = (wxEvent *)(arg1)->Clone();
14962
14963 wxPyEndAllowThreads(__tstate);
14964 if (PyErr_Occurred()) SWIG_fail;
14965 }
14966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14967 return resultobj;
14968 fail:
14969 return NULL;
14970 }
14971
14972
14973 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14974 PyObject *obj;
14975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14976 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14977 Py_INCREF(obj);
14978 return Py_BuildValue((char *)"");
14979 }
14980 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14981 PyObject *resultobj;
14982 wxEvent *arg1 = 0 ;
14983 wxPropagationDisabler *result;
14984 PyObject * obj0 = 0 ;
14985 char *kwnames[] = {
14986 (char *) "event", NULL
14987 };
14988
14989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14990 {
14991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14992 if (SWIG_arg_fail(1)) SWIG_fail;
14993 if (arg1 == NULL) {
14994 SWIG_null_ref("wxEvent");
14995 }
14996 if (SWIG_arg_fail(1)) SWIG_fail;
14997 }
14998 {
14999 PyThreadState* __tstate = wxPyBeginAllowThreads();
15000 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15001
15002 wxPyEndAllowThreads(__tstate);
15003 if (PyErr_Occurred()) SWIG_fail;
15004 }
15005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15006 return resultobj;
15007 fail:
15008 return NULL;
15009 }
15010
15011
15012 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15013 PyObject *resultobj;
15014 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15015 PyObject * obj0 = 0 ;
15016 char *kwnames[] = {
15017 (char *) "self", NULL
15018 };
15019
15020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15022 if (SWIG_arg_fail(1)) SWIG_fail;
15023 {
15024 PyThreadState* __tstate = wxPyBeginAllowThreads();
15025 delete arg1;
15026
15027 wxPyEndAllowThreads(__tstate);
15028 if (PyErr_Occurred()) SWIG_fail;
15029 }
15030 Py_INCREF(Py_None); resultobj = Py_None;
15031 return resultobj;
15032 fail:
15033 return NULL;
15034 }
15035
15036
15037 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15038 PyObject *obj;
15039 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15040 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15041 Py_INCREF(obj);
15042 return Py_BuildValue((char *)"");
15043 }
15044 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15045 PyObject *resultobj;
15046 wxEvent *arg1 = 0 ;
15047 wxPropagateOnce *result;
15048 PyObject * obj0 = 0 ;
15049 char *kwnames[] = {
15050 (char *) "event", NULL
15051 };
15052
15053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15054 {
15055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15056 if (SWIG_arg_fail(1)) SWIG_fail;
15057 if (arg1 == NULL) {
15058 SWIG_null_ref("wxEvent");
15059 }
15060 if (SWIG_arg_fail(1)) SWIG_fail;
15061 }
15062 {
15063 PyThreadState* __tstate = wxPyBeginAllowThreads();
15064 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15065
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15070 return resultobj;
15071 fail:
15072 return NULL;
15073 }
15074
15075
15076 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15077 PyObject *resultobj;
15078 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15079 PyObject * obj0 = 0 ;
15080 char *kwnames[] = {
15081 (char *) "self", NULL
15082 };
15083
15084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15086 if (SWIG_arg_fail(1)) SWIG_fail;
15087 {
15088 PyThreadState* __tstate = wxPyBeginAllowThreads();
15089 delete arg1;
15090
15091 wxPyEndAllowThreads(__tstate);
15092 if (PyErr_Occurred()) SWIG_fail;
15093 }
15094 Py_INCREF(Py_None); resultobj = Py_None;
15095 return resultobj;
15096 fail:
15097 return NULL;
15098 }
15099
15100
15101 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15102 PyObject *obj;
15103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15104 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15105 Py_INCREF(obj);
15106 return Py_BuildValue((char *)"");
15107 }
15108 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15109 PyObject *resultobj;
15110 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15111 int arg2 = (int) 0 ;
15112 wxCommandEvent *result;
15113 PyObject * obj0 = 0 ;
15114 PyObject * obj1 = 0 ;
15115 char *kwnames[] = {
15116 (char *) "commandType",(char *) "winid", NULL
15117 };
15118
15119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15120 if (obj0) {
15121 {
15122 arg1 = (wxEventType)(SWIG_As_int(obj0));
15123 if (SWIG_arg_fail(1)) SWIG_fail;
15124 }
15125 }
15126 if (obj1) {
15127 {
15128 arg2 = (int)(SWIG_As_int(obj1));
15129 if (SWIG_arg_fail(2)) SWIG_fail;
15130 }
15131 }
15132 {
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15135
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15140 return resultobj;
15141 fail:
15142 return NULL;
15143 }
15144
15145
15146 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15147 PyObject *resultobj;
15148 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15149 int result;
15150 PyObject * obj0 = 0 ;
15151 char *kwnames[] = {
15152 (char *) "self", NULL
15153 };
15154
15155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15157 if (SWIG_arg_fail(1)) SWIG_fail;
15158 {
15159 PyThreadState* __tstate = wxPyBeginAllowThreads();
15160 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15161
15162 wxPyEndAllowThreads(__tstate);
15163 if (PyErr_Occurred()) SWIG_fail;
15164 }
15165 {
15166 resultobj = SWIG_From_int((int)(result));
15167 }
15168 return resultobj;
15169 fail:
15170 return NULL;
15171 }
15172
15173
15174 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15175 PyObject *resultobj;
15176 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15177 wxString *arg2 = 0 ;
15178 bool temp2 = false ;
15179 PyObject * obj0 = 0 ;
15180 PyObject * obj1 = 0 ;
15181 char *kwnames[] = {
15182 (char *) "self",(char *) "s", NULL
15183 };
15184
15185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15187 if (SWIG_arg_fail(1)) SWIG_fail;
15188 {
15189 arg2 = wxString_in_helper(obj1);
15190 if (arg2 == NULL) SWIG_fail;
15191 temp2 = true;
15192 }
15193 {
15194 PyThreadState* __tstate = wxPyBeginAllowThreads();
15195 (arg1)->SetString((wxString const &)*arg2);
15196
15197 wxPyEndAllowThreads(__tstate);
15198 if (PyErr_Occurred()) SWIG_fail;
15199 }
15200 Py_INCREF(Py_None); resultobj = Py_None;
15201 {
15202 if (temp2)
15203 delete arg2;
15204 }
15205 return resultobj;
15206 fail:
15207 {
15208 if (temp2)
15209 delete arg2;
15210 }
15211 return NULL;
15212 }
15213
15214
15215 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15216 PyObject *resultobj;
15217 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15218 wxString result;
15219 PyObject * obj0 = 0 ;
15220 char *kwnames[] = {
15221 (char *) "self", NULL
15222 };
15223
15224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15226 if (SWIG_arg_fail(1)) SWIG_fail;
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 result = ((wxCommandEvent const *)arg1)->GetString();
15230
15231 wxPyEndAllowThreads(__tstate);
15232 if (PyErr_Occurred()) SWIG_fail;
15233 }
15234 {
15235 #if wxUSE_UNICODE
15236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15237 #else
15238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15239 #endif
15240 }
15241 return resultobj;
15242 fail:
15243 return NULL;
15244 }
15245
15246
15247 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15248 PyObject *resultobj;
15249 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15250 bool result;
15251 PyObject * obj0 = 0 ;
15252 char *kwnames[] = {
15253 (char *) "self", NULL
15254 };
15255
15256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15258 if (SWIG_arg_fail(1)) SWIG_fail;
15259 {
15260 PyThreadState* __tstate = wxPyBeginAllowThreads();
15261 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15262
15263 wxPyEndAllowThreads(__tstate);
15264 if (PyErr_Occurred()) SWIG_fail;
15265 }
15266 {
15267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15268 }
15269 return resultobj;
15270 fail:
15271 return NULL;
15272 }
15273
15274
15275 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15276 PyObject *resultobj;
15277 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15278 bool result;
15279 PyObject * obj0 = 0 ;
15280 char *kwnames[] = {
15281 (char *) "self", NULL
15282 };
15283
15284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15286 if (SWIG_arg_fail(1)) SWIG_fail;
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 {
15295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15296 }
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15304 PyObject *resultobj;
15305 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15306 long arg2 ;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char *kwnames[] = {
15310 (char *) "self",(char *) "extraLong", NULL
15311 };
15312
15313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15315 if (SWIG_arg_fail(1)) SWIG_fail;
15316 {
15317 arg2 = (long)(SWIG_As_long(obj1));
15318 if (SWIG_arg_fail(2)) SWIG_fail;
15319 }
15320 {
15321 PyThreadState* __tstate = wxPyBeginAllowThreads();
15322 (arg1)->SetExtraLong(arg2);
15323
15324 wxPyEndAllowThreads(__tstate);
15325 if (PyErr_Occurred()) SWIG_fail;
15326 }
15327 Py_INCREF(Py_None); resultobj = Py_None;
15328 return resultobj;
15329 fail:
15330 return NULL;
15331 }
15332
15333
15334 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15335 PyObject *resultobj;
15336 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15337 long result;
15338 PyObject * obj0 = 0 ;
15339 char *kwnames[] = {
15340 (char *) "self", NULL
15341 };
15342
15343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15345 if (SWIG_arg_fail(1)) SWIG_fail;
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15349
15350 wxPyEndAllowThreads(__tstate);
15351 if (PyErr_Occurred()) SWIG_fail;
15352 }
15353 {
15354 resultobj = SWIG_From_long((long)(result));
15355 }
15356 return resultobj;
15357 fail:
15358 return NULL;
15359 }
15360
15361
15362 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15363 PyObject *resultobj;
15364 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15365 int arg2 ;
15366 PyObject * obj0 = 0 ;
15367 PyObject * obj1 = 0 ;
15368 char *kwnames[] = {
15369 (char *) "self",(char *) "i", NULL
15370 };
15371
15372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15374 if (SWIG_arg_fail(1)) SWIG_fail;
15375 {
15376 arg2 = (int)(SWIG_As_int(obj1));
15377 if (SWIG_arg_fail(2)) SWIG_fail;
15378 }
15379 {
15380 PyThreadState* __tstate = wxPyBeginAllowThreads();
15381 (arg1)->SetInt(arg2);
15382
15383 wxPyEndAllowThreads(__tstate);
15384 if (PyErr_Occurred()) SWIG_fail;
15385 }
15386 Py_INCREF(Py_None); resultobj = Py_None;
15387 return resultobj;
15388 fail:
15389 return NULL;
15390 }
15391
15392
15393 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15394 PyObject *resultobj;
15395 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15396 long result;
15397 PyObject * obj0 = 0 ;
15398 char *kwnames[] = {
15399 (char *) "self", NULL
15400 };
15401
15402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15404 if (SWIG_arg_fail(1)) SWIG_fail;
15405 {
15406 PyThreadState* __tstate = wxPyBeginAllowThreads();
15407 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15408
15409 wxPyEndAllowThreads(__tstate);
15410 if (PyErr_Occurred()) SWIG_fail;
15411 }
15412 {
15413 resultobj = SWIG_From_long((long)(result));
15414 }
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15422 PyObject *resultobj;
15423 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15424 wxEvent *result;
15425 PyObject * obj0 = 0 ;
15426 char *kwnames[] = {
15427 (char *) "self", NULL
15428 };
15429
15430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15432 if (SWIG_arg_fail(1)) SWIG_fail;
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15436
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15448 PyObject *obj;
15449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15450 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15451 Py_INCREF(obj);
15452 return Py_BuildValue((char *)"");
15453 }
15454 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15455 PyObject *resultobj;
15456 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15457 int arg2 = (int) 0 ;
15458 wxNotifyEvent *result;
15459 PyObject * obj0 = 0 ;
15460 PyObject * obj1 = 0 ;
15461 char *kwnames[] = {
15462 (char *) "commandType",(char *) "winid", NULL
15463 };
15464
15465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15466 if (obj0) {
15467 {
15468 arg1 = (wxEventType)(SWIG_As_int(obj0));
15469 if (SWIG_arg_fail(1)) SWIG_fail;
15470 }
15471 }
15472 if (obj1) {
15473 {
15474 arg2 = (int)(SWIG_As_int(obj1));
15475 if (SWIG_arg_fail(2)) SWIG_fail;
15476 }
15477 }
15478 {
15479 PyThreadState* __tstate = wxPyBeginAllowThreads();
15480 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15481
15482 wxPyEndAllowThreads(__tstate);
15483 if (PyErr_Occurred()) SWIG_fail;
15484 }
15485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15486 return resultobj;
15487 fail:
15488 return NULL;
15489 }
15490
15491
15492 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15493 PyObject *resultobj;
15494 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15495 PyObject * obj0 = 0 ;
15496 char *kwnames[] = {
15497 (char *) "self", NULL
15498 };
15499
15500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15502 if (SWIG_arg_fail(1)) SWIG_fail;
15503 {
15504 PyThreadState* __tstate = wxPyBeginAllowThreads();
15505 (arg1)->Veto();
15506
15507 wxPyEndAllowThreads(__tstate);
15508 if (PyErr_Occurred()) SWIG_fail;
15509 }
15510 Py_INCREF(Py_None); resultobj = Py_None;
15511 return resultobj;
15512 fail:
15513 return NULL;
15514 }
15515
15516
15517 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15518 PyObject *resultobj;
15519 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15520 PyObject * obj0 = 0 ;
15521 char *kwnames[] = {
15522 (char *) "self", NULL
15523 };
15524
15525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15527 if (SWIG_arg_fail(1)) SWIG_fail;
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 (arg1)->Allow();
15531
15532 wxPyEndAllowThreads(__tstate);
15533 if (PyErr_Occurred()) SWIG_fail;
15534 }
15535 Py_INCREF(Py_None); resultobj = Py_None;
15536 return resultobj;
15537 fail:
15538 return NULL;
15539 }
15540
15541
15542 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15543 PyObject *resultobj;
15544 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15545 bool result;
15546 PyObject * obj0 = 0 ;
15547 char *kwnames[] = {
15548 (char *) "self", NULL
15549 };
15550
15551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15553 if (SWIG_arg_fail(1)) SWIG_fail;
15554 {
15555 PyThreadState* __tstate = wxPyBeginAllowThreads();
15556 result = (bool)(arg1)->IsAllowed();
15557
15558 wxPyEndAllowThreads(__tstate);
15559 if (PyErr_Occurred()) SWIG_fail;
15560 }
15561 {
15562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15563 }
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15571 PyObject *obj;
15572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15573 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15574 Py_INCREF(obj);
15575 return Py_BuildValue((char *)"");
15576 }
15577 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15578 PyObject *resultobj;
15579 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15580 int arg2 = (int) 0 ;
15581 int arg3 = (int) 0 ;
15582 int arg4 = (int) 0 ;
15583 wxScrollEvent *result;
15584 PyObject * obj0 = 0 ;
15585 PyObject * obj1 = 0 ;
15586 PyObject * obj2 = 0 ;
15587 PyObject * obj3 = 0 ;
15588 char *kwnames[] = {
15589 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15590 };
15591
15592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15593 if (obj0) {
15594 {
15595 arg1 = (wxEventType)(SWIG_As_int(obj0));
15596 if (SWIG_arg_fail(1)) SWIG_fail;
15597 }
15598 }
15599 if (obj1) {
15600 {
15601 arg2 = (int)(SWIG_As_int(obj1));
15602 if (SWIG_arg_fail(2)) SWIG_fail;
15603 }
15604 }
15605 if (obj2) {
15606 {
15607 arg3 = (int)(SWIG_As_int(obj2));
15608 if (SWIG_arg_fail(3)) SWIG_fail;
15609 }
15610 }
15611 if (obj3) {
15612 {
15613 arg4 = (int)(SWIG_As_int(obj3));
15614 if (SWIG_arg_fail(4)) SWIG_fail;
15615 }
15616 }
15617 {
15618 PyThreadState* __tstate = wxPyBeginAllowThreads();
15619 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15620
15621 wxPyEndAllowThreads(__tstate);
15622 if (PyErr_Occurred()) SWIG_fail;
15623 }
15624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15625 return resultobj;
15626 fail:
15627 return NULL;
15628 }
15629
15630
15631 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15632 PyObject *resultobj;
15633 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15634 int result;
15635 PyObject * obj0 = 0 ;
15636 char *kwnames[] = {
15637 (char *) "self", NULL
15638 };
15639
15640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15642 if (SWIG_arg_fail(1)) SWIG_fail;
15643 {
15644 PyThreadState* __tstate = wxPyBeginAllowThreads();
15645 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15646
15647 wxPyEndAllowThreads(__tstate);
15648 if (PyErr_Occurred()) SWIG_fail;
15649 }
15650 {
15651 resultobj = SWIG_From_int((int)(result));
15652 }
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15660 PyObject *resultobj;
15661 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15662 int result;
15663 PyObject * obj0 = 0 ;
15664 char *kwnames[] = {
15665 (char *) "self", NULL
15666 };
15667
15668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15670 if (SWIG_arg_fail(1)) SWIG_fail;
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15674
15675 wxPyEndAllowThreads(__tstate);
15676 if (PyErr_Occurred()) SWIG_fail;
15677 }
15678 {
15679 resultobj = SWIG_From_int((int)(result));
15680 }
15681 return resultobj;
15682 fail:
15683 return NULL;
15684 }
15685
15686
15687 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15688 PyObject *resultobj;
15689 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15690 int arg2 ;
15691 PyObject * obj0 = 0 ;
15692 PyObject * obj1 = 0 ;
15693 char *kwnames[] = {
15694 (char *) "self",(char *) "orient", NULL
15695 };
15696
15697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15699 if (SWIG_arg_fail(1)) SWIG_fail;
15700 {
15701 arg2 = (int)(SWIG_As_int(obj1));
15702 if (SWIG_arg_fail(2)) SWIG_fail;
15703 }
15704 {
15705 PyThreadState* __tstate = wxPyBeginAllowThreads();
15706 (arg1)->SetOrientation(arg2);
15707
15708 wxPyEndAllowThreads(__tstate);
15709 if (PyErr_Occurred()) SWIG_fail;
15710 }
15711 Py_INCREF(Py_None); resultobj = Py_None;
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj;
15720 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15721 int arg2 ;
15722 PyObject * obj0 = 0 ;
15723 PyObject * obj1 = 0 ;
15724 char *kwnames[] = {
15725 (char *) "self",(char *) "pos", NULL
15726 };
15727
15728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15730 if (SWIG_arg_fail(1)) SWIG_fail;
15731 {
15732 arg2 = (int)(SWIG_As_int(obj1));
15733 if (SWIG_arg_fail(2)) SWIG_fail;
15734 }
15735 {
15736 PyThreadState* __tstate = wxPyBeginAllowThreads();
15737 (arg1)->SetPosition(arg2);
15738
15739 wxPyEndAllowThreads(__tstate);
15740 if (PyErr_Occurred()) SWIG_fail;
15741 }
15742 Py_INCREF(Py_None); resultobj = Py_None;
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15750 PyObject *obj;
15751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15752 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15753 Py_INCREF(obj);
15754 return Py_BuildValue((char *)"");
15755 }
15756 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15757 PyObject *resultobj;
15758 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15759 int arg2 = (int) 0 ;
15760 int arg3 = (int) 0 ;
15761 wxScrollWinEvent *result;
15762 PyObject * obj0 = 0 ;
15763 PyObject * obj1 = 0 ;
15764 PyObject * obj2 = 0 ;
15765 char *kwnames[] = {
15766 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15767 };
15768
15769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15770 if (obj0) {
15771 {
15772 arg1 = (wxEventType)(SWIG_As_int(obj0));
15773 if (SWIG_arg_fail(1)) SWIG_fail;
15774 }
15775 }
15776 if (obj1) {
15777 {
15778 arg2 = (int)(SWIG_As_int(obj1));
15779 if (SWIG_arg_fail(2)) SWIG_fail;
15780 }
15781 }
15782 if (obj2) {
15783 {
15784 arg3 = (int)(SWIG_As_int(obj2));
15785 if (SWIG_arg_fail(3)) SWIG_fail;
15786 }
15787 }
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15791
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15796 return resultobj;
15797 fail:
15798 return NULL;
15799 }
15800
15801
15802 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15803 PyObject *resultobj;
15804 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15805 int result;
15806 PyObject * obj0 = 0 ;
15807 char *kwnames[] = {
15808 (char *) "self", NULL
15809 };
15810
15811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15813 if (SWIG_arg_fail(1)) SWIG_fail;
15814 {
15815 PyThreadState* __tstate = wxPyBeginAllowThreads();
15816 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15817
15818 wxPyEndAllowThreads(__tstate);
15819 if (PyErr_Occurred()) SWIG_fail;
15820 }
15821 {
15822 resultobj = SWIG_From_int((int)(result));
15823 }
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15831 PyObject *resultobj;
15832 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15833 int result;
15834 PyObject * obj0 = 0 ;
15835 char *kwnames[] = {
15836 (char *) "self", NULL
15837 };
15838
15839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15841 if (SWIG_arg_fail(1)) SWIG_fail;
15842 {
15843 PyThreadState* __tstate = wxPyBeginAllowThreads();
15844 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15845
15846 wxPyEndAllowThreads(__tstate);
15847 if (PyErr_Occurred()) SWIG_fail;
15848 }
15849 {
15850 resultobj = SWIG_From_int((int)(result));
15851 }
15852 return resultobj;
15853 fail:
15854 return NULL;
15855 }
15856
15857
15858 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15859 PyObject *resultobj;
15860 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15861 int arg2 ;
15862 PyObject * obj0 = 0 ;
15863 PyObject * obj1 = 0 ;
15864 char *kwnames[] = {
15865 (char *) "self",(char *) "orient", NULL
15866 };
15867
15868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15870 if (SWIG_arg_fail(1)) SWIG_fail;
15871 {
15872 arg2 = (int)(SWIG_As_int(obj1));
15873 if (SWIG_arg_fail(2)) SWIG_fail;
15874 }
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 (arg1)->SetOrientation(arg2);
15878
15879 wxPyEndAllowThreads(__tstate);
15880 if (PyErr_Occurred()) SWIG_fail;
15881 }
15882 Py_INCREF(Py_None); resultobj = Py_None;
15883 return resultobj;
15884 fail:
15885 return NULL;
15886 }
15887
15888
15889 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15890 PyObject *resultobj;
15891 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15892 int arg2 ;
15893 PyObject * obj0 = 0 ;
15894 PyObject * obj1 = 0 ;
15895 char *kwnames[] = {
15896 (char *) "self",(char *) "pos", NULL
15897 };
15898
15899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15901 if (SWIG_arg_fail(1)) SWIG_fail;
15902 {
15903 arg2 = (int)(SWIG_As_int(obj1));
15904 if (SWIG_arg_fail(2)) SWIG_fail;
15905 }
15906 {
15907 PyThreadState* __tstate = wxPyBeginAllowThreads();
15908 (arg1)->SetPosition(arg2);
15909
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 Py_INCREF(Py_None); resultobj = Py_None;
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15921 PyObject *obj;
15922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15923 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15924 Py_INCREF(obj);
15925 return Py_BuildValue((char *)"");
15926 }
15927 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15928 PyObject *resultobj;
15929 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15930 wxMouseEvent *result;
15931 PyObject * obj0 = 0 ;
15932 char *kwnames[] = {
15933 (char *) "mouseType", NULL
15934 };
15935
15936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15937 if (obj0) {
15938 {
15939 arg1 = (wxEventType)(SWIG_As_int(obj0));
15940 if (SWIG_arg_fail(1)) SWIG_fail;
15941 }
15942 }
15943 {
15944 PyThreadState* __tstate = wxPyBeginAllowThreads();
15945 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15946
15947 wxPyEndAllowThreads(__tstate);
15948 if (PyErr_Occurred()) SWIG_fail;
15949 }
15950 {
15951 resultobj = wxPyMake_wxObject(result, 1);
15952 }
15953 return resultobj;
15954 fail:
15955 return NULL;
15956 }
15957
15958
15959 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15960 PyObject *resultobj;
15961 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15962 bool result;
15963 PyObject * obj0 = 0 ;
15964 char *kwnames[] = {
15965 (char *) "self", NULL
15966 };
15967
15968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15970 if (SWIG_arg_fail(1)) SWIG_fail;
15971 {
15972 PyThreadState* __tstate = wxPyBeginAllowThreads();
15973 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15974
15975 wxPyEndAllowThreads(__tstate);
15976 if (PyErr_Occurred()) SWIG_fail;
15977 }
15978 {
15979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15980 }
15981 return resultobj;
15982 fail:
15983 return NULL;
15984 }
15985
15986
15987 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15988 PyObject *resultobj;
15989 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15990 int arg2 = (int) wxMOUSE_BTN_ANY ;
15991 bool result;
15992 PyObject * obj0 = 0 ;
15993 PyObject * obj1 = 0 ;
15994 char *kwnames[] = {
15995 (char *) "self",(char *) "but", NULL
15996 };
15997
15998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16000 if (SWIG_arg_fail(1)) SWIG_fail;
16001 if (obj1) {
16002 {
16003 arg2 = (int)(SWIG_As_int(obj1));
16004 if (SWIG_arg_fail(2)) SWIG_fail;
16005 }
16006 }
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16010
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 {
16015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16016 }
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj;
16025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16026 int arg2 = (int) wxMOUSE_BTN_ANY ;
16027 bool result;
16028 PyObject * obj0 = 0 ;
16029 PyObject * obj1 = 0 ;
16030 char *kwnames[] = {
16031 (char *) "self",(char *) "but", NULL
16032 };
16033
16034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16036 if (SWIG_arg_fail(1)) SWIG_fail;
16037 if (obj1) {
16038 {
16039 arg2 = (int)(SWIG_As_int(obj1));
16040 if (SWIG_arg_fail(2)) SWIG_fail;
16041 }
16042 }
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
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 *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj;
16061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16062 int arg2 = (int) wxMOUSE_BTN_ANY ;
16063 bool result;
16064 PyObject * obj0 = 0 ;
16065 PyObject * obj1 = 0 ;
16066 char *kwnames[] = {
16067 (char *) "self",(char *) "but", NULL
16068 };
16069
16070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16072 if (SWIG_arg_fail(1)) SWIG_fail;
16073 if (obj1) {
16074 {
16075 arg2 = (int)(SWIG_As_int(obj1));
16076 if (SWIG_arg_fail(2)) SWIG_fail;
16077 }
16078 }
16079 {
16080 PyThreadState* __tstate = wxPyBeginAllowThreads();
16081 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16082
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 {
16087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16088 }
16089 return resultobj;
16090 fail:
16091 return NULL;
16092 }
16093
16094
16095 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16096 PyObject *resultobj;
16097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16098 int arg2 ;
16099 bool result;
16100 PyObject * obj0 = 0 ;
16101 PyObject * obj1 = 0 ;
16102 char *kwnames[] = {
16103 (char *) "self",(char *) "but", NULL
16104 };
16105
16106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16108 if (SWIG_arg_fail(1)) SWIG_fail;
16109 {
16110 arg2 = (int)(SWIG_As_int(obj1));
16111 if (SWIG_arg_fail(2)) SWIG_fail;
16112 }
16113 {
16114 PyThreadState* __tstate = wxPyBeginAllowThreads();
16115 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16116
16117 wxPyEndAllowThreads(__tstate);
16118 if (PyErr_Occurred()) SWIG_fail;
16119 }
16120 {
16121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16122 }
16123 return resultobj;
16124 fail:
16125 return NULL;
16126 }
16127
16128
16129 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16130 PyObject *resultobj;
16131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16132 int arg2 ;
16133 bool result;
16134 PyObject * obj0 = 0 ;
16135 PyObject * obj1 = 0 ;
16136 char *kwnames[] = {
16137 (char *) "self",(char *) "but", NULL
16138 };
16139
16140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16142 if (SWIG_arg_fail(1)) SWIG_fail;
16143 {
16144 arg2 = (int)(SWIG_As_int(obj1));
16145 if (SWIG_arg_fail(2)) SWIG_fail;
16146 }
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16150
16151 wxPyEndAllowThreads(__tstate);
16152 if (PyErr_Occurred()) SWIG_fail;
16153 }
16154 {
16155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16156 }
16157 return resultobj;
16158 fail:
16159 return NULL;
16160 }
16161
16162
16163 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16164 PyObject *resultobj;
16165 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16166 int result;
16167 PyObject * obj0 = 0 ;
16168 char *kwnames[] = {
16169 (char *) "self", NULL
16170 };
16171
16172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16174 if (SWIG_arg_fail(1)) SWIG_fail;
16175 {
16176 PyThreadState* __tstate = wxPyBeginAllowThreads();
16177 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16178
16179 wxPyEndAllowThreads(__tstate);
16180 if (PyErr_Occurred()) SWIG_fail;
16181 }
16182 {
16183 resultobj = SWIG_From_int((int)(result));
16184 }
16185 return resultobj;
16186 fail:
16187 return NULL;
16188 }
16189
16190
16191 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16192 PyObject *resultobj;
16193 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16194 bool result;
16195 PyObject * obj0 = 0 ;
16196 char *kwnames[] = {
16197 (char *) "self", NULL
16198 };
16199
16200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16202 if (SWIG_arg_fail(1)) SWIG_fail;
16203 {
16204 PyThreadState* __tstate = wxPyBeginAllowThreads();
16205 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16206
16207 wxPyEndAllowThreads(__tstate);
16208 if (PyErr_Occurred()) SWIG_fail;
16209 }
16210 {
16211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16212 }
16213 return resultobj;
16214 fail:
16215 return NULL;
16216 }
16217
16218
16219 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16220 PyObject *resultobj;
16221 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16222 bool result;
16223 PyObject * obj0 = 0 ;
16224 char *kwnames[] = {
16225 (char *) "self", NULL
16226 };
16227
16228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16230 if (SWIG_arg_fail(1)) SWIG_fail;
16231 {
16232 PyThreadState* __tstate = wxPyBeginAllowThreads();
16233 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16234
16235 wxPyEndAllowThreads(__tstate);
16236 if (PyErr_Occurred()) SWIG_fail;
16237 }
16238 {
16239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16240 }
16241 return resultobj;
16242 fail:
16243 return NULL;
16244 }
16245
16246
16247 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16248 PyObject *resultobj;
16249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16250 bool result;
16251 PyObject * obj0 = 0 ;
16252 char *kwnames[] = {
16253 (char *) "self", NULL
16254 };
16255
16256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16258 if (SWIG_arg_fail(1)) SWIG_fail;
16259 {
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16262
16263 wxPyEndAllowThreads(__tstate);
16264 if (PyErr_Occurred()) SWIG_fail;
16265 }
16266 {
16267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16268 }
16269 return resultobj;
16270 fail:
16271 return NULL;
16272 }
16273
16274
16275 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16276 PyObject *resultobj;
16277 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16278 bool result;
16279 PyObject * obj0 = 0 ;
16280 char *kwnames[] = {
16281 (char *) "self", NULL
16282 };
16283
16284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16286 if (SWIG_arg_fail(1)) SWIG_fail;
16287 {
16288 PyThreadState* __tstate = wxPyBeginAllowThreads();
16289 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16290
16291 wxPyEndAllowThreads(__tstate);
16292 if (PyErr_Occurred()) SWIG_fail;
16293 }
16294 {
16295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16296 }
16297 return resultobj;
16298 fail:
16299 return NULL;
16300 }
16301
16302
16303 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16304 PyObject *resultobj;
16305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16306 bool result;
16307 PyObject * obj0 = 0 ;
16308 char *kwnames[] = {
16309 (char *) "self", NULL
16310 };
16311
16312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16314 if (SWIG_arg_fail(1)) SWIG_fail;
16315 {
16316 PyThreadState* __tstate = wxPyBeginAllowThreads();
16317 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16318
16319 wxPyEndAllowThreads(__tstate);
16320 if (PyErr_Occurred()) SWIG_fail;
16321 }
16322 {
16323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16324 }
16325 return resultobj;
16326 fail:
16327 return NULL;
16328 }
16329
16330
16331 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16332 PyObject *resultobj;
16333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16334 bool result;
16335 PyObject * obj0 = 0 ;
16336 char *kwnames[] = {
16337 (char *) "self", NULL
16338 };
16339
16340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16342 if (SWIG_arg_fail(1)) SWIG_fail;
16343 {
16344 PyThreadState* __tstate = wxPyBeginAllowThreads();
16345 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16346
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 {
16351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16352 }
16353 return resultobj;
16354 fail:
16355 return NULL;
16356 }
16357
16358
16359 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj;
16361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16362 bool result;
16363 PyObject * obj0 = 0 ;
16364 char *kwnames[] = {
16365 (char *) "self", NULL
16366 };
16367
16368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16370 if (SWIG_arg_fail(1)) SWIG_fail;
16371 {
16372 PyThreadState* __tstate = wxPyBeginAllowThreads();
16373 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16374
16375 wxPyEndAllowThreads(__tstate);
16376 if (PyErr_Occurred()) SWIG_fail;
16377 }
16378 {
16379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16380 }
16381 return resultobj;
16382 fail:
16383 return NULL;
16384 }
16385
16386
16387 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj;
16389 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16390 bool result;
16391 PyObject * obj0 = 0 ;
16392 char *kwnames[] = {
16393 (char *) "self", NULL
16394 };
16395
16396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16398 if (SWIG_arg_fail(1)) SWIG_fail;
16399 {
16400 PyThreadState* __tstate = wxPyBeginAllowThreads();
16401 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16402
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 {
16407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16408 }
16409 return resultobj;
16410 fail:
16411 return NULL;
16412 }
16413
16414
16415 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16416 PyObject *resultobj;
16417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16418 bool result;
16419 PyObject * obj0 = 0 ;
16420 char *kwnames[] = {
16421 (char *) "self", NULL
16422 };
16423
16424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16426 if (SWIG_arg_fail(1)) SWIG_fail;
16427 {
16428 PyThreadState* __tstate = wxPyBeginAllowThreads();
16429 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16430
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 {
16435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16436 }
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj;
16445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16446 bool result;
16447 PyObject * obj0 = 0 ;
16448 char *kwnames[] = {
16449 (char *) "self", NULL
16450 };
16451
16452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16454 if (SWIG_arg_fail(1)) SWIG_fail;
16455 {
16456 PyThreadState* __tstate = wxPyBeginAllowThreads();
16457 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16458
16459 wxPyEndAllowThreads(__tstate);
16460 if (PyErr_Occurred()) SWIG_fail;
16461 }
16462 {
16463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16464 }
16465 return resultobj;
16466 fail:
16467 return NULL;
16468 }
16469
16470
16471 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16472 PyObject *resultobj;
16473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16474 bool result;
16475 PyObject * obj0 = 0 ;
16476 char *kwnames[] = {
16477 (char *) "self", NULL
16478 };
16479
16480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16482 if (SWIG_arg_fail(1)) SWIG_fail;
16483 {
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16486
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 {
16491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16492 }
16493 return resultobj;
16494 fail:
16495 return NULL;
16496 }
16497
16498
16499 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16500 PyObject *resultobj;
16501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16502 bool result;
16503 PyObject * obj0 = 0 ;
16504 char *kwnames[] = {
16505 (char *) "self", NULL
16506 };
16507
16508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16510 if (SWIG_arg_fail(1)) SWIG_fail;
16511 {
16512 PyThreadState* __tstate = wxPyBeginAllowThreads();
16513 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16514
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 {
16519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16520 }
16521 return resultobj;
16522 fail:
16523 return NULL;
16524 }
16525
16526
16527 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16528 PyObject *resultobj;
16529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16530 bool result;
16531 PyObject * obj0 = 0 ;
16532 char *kwnames[] = {
16533 (char *) "self", NULL
16534 };
16535
16536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16538 if (SWIG_arg_fail(1)) SWIG_fail;
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16542
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 {
16547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16548 }
16549 return resultobj;
16550 fail:
16551 return NULL;
16552 }
16553
16554
16555 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16556 PyObject *resultobj;
16557 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16558 bool result;
16559 PyObject * obj0 = 0 ;
16560 char *kwnames[] = {
16561 (char *) "self", NULL
16562 };
16563
16564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16566 if (SWIG_arg_fail(1)) SWIG_fail;
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16570
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 {
16575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16576 }
16577 return resultobj;
16578 fail:
16579 return NULL;
16580 }
16581
16582
16583 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16584 PyObject *resultobj;
16585 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16586 bool result;
16587 PyObject * obj0 = 0 ;
16588 char *kwnames[] = {
16589 (char *) "self", NULL
16590 };
16591
16592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16594 if (SWIG_arg_fail(1)) SWIG_fail;
16595 {
16596 PyThreadState* __tstate = wxPyBeginAllowThreads();
16597 result = (bool)(arg1)->LeftIsDown();
16598
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 {
16603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16604 }
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16612 PyObject *resultobj;
16613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16614 bool result;
16615 PyObject * obj0 = 0 ;
16616 char *kwnames[] = {
16617 (char *) "self", NULL
16618 };
16619
16620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16622 if (SWIG_arg_fail(1)) SWIG_fail;
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 result = (bool)(arg1)->MiddleIsDown();
16626
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 {
16631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16632 }
16633 return resultobj;
16634 fail:
16635 return NULL;
16636 }
16637
16638
16639 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16640 PyObject *resultobj;
16641 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16642 bool result;
16643 PyObject * obj0 = 0 ;
16644 char *kwnames[] = {
16645 (char *) "self", NULL
16646 };
16647
16648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16650 if (SWIG_arg_fail(1)) SWIG_fail;
16651 {
16652 PyThreadState* __tstate = wxPyBeginAllowThreads();
16653 result = (bool)(arg1)->RightIsDown();
16654
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 {
16659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16660 }
16661 return resultobj;
16662 fail:
16663 return NULL;
16664 }
16665
16666
16667 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16668 PyObject *resultobj;
16669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16670 bool result;
16671 PyObject * obj0 = 0 ;
16672 char *kwnames[] = {
16673 (char *) "self", NULL
16674 };
16675
16676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16678 if (SWIG_arg_fail(1)) SWIG_fail;
16679 {
16680 PyThreadState* __tstate = wxPyBeginAllowThreads();
16681 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16682
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 {
16687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16688 }
16689 return resultobj;
16690 fail:
16691 return NULL;
16692 }
16693
16694
16695 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16696 PyObject *resultobj;
16697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16698 bool result;
16699 PyObject * obj0 = 0 ;
16700 char *kwnames[] = {
16701 (char *) "self", NULL
16702 };
16703
16704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16706 if (SWIG_arg_fail(1)) SWIG_fail;
16707 {
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16710
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 {
16715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16716 }
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj;
16725 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16726 bool result;
16727 PyObject * obj0 = 0 ;
16728 char *kwnames[] = {
16729 (char *) "self", NULL
16730 };
16731
16732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16734 if (SWIG_arg_fail(1)) SWIG_fail;
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16738
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 {
16743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16744 }
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj;
16753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16754 bool result;
16755 PyObject * obj0 = 0 ;
16756 char *kwnames[] = {
16757 (char *) "self", NULL
16758 };
16759
16760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16762 if (SWIG_arg_fail(1)) SWIG_fail;
16763 {
16764 PyThreadState* __tstate = wxPyBeginAllowThreads();
16765 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16766
16767 wxPyEndAllowThreads(__tstate);
16768 if (PyErr_Occurred()) SWIG_fail;
16769 }
16770 {
16771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16772 }
16773 return resultobj;
16774 fail:
16775 return NULL;
16776 }
16777
16778
16779 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16780 PyObject *resultobj;
16781 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16782 wxPoint result;
16783 PyObject * obj0 = 0 ;
16784 char *kwnames[] = {
16785 (char *) "self", NULL
16786 };
16787
16788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16790 if (SWIG_arg_fail(1)) SWIG_fail;
16791 {
16792 PyThreadState* __tstate = wxPyBeginAllowThreads();
16793 result = (arg1)->GetPosition();
16794
16795 wxPyEndAllowThreads(__tstate);
16796 if (PyErr_Occurred()) SWIG_fail;
16797 }
16798 {
16799 wxPoint * resultptr;
16800 resultptr = new wxPoint((wxPoint &)(result));
16801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16802 }
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16810 PyObject *resultobj;
16811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16812 long *arg2 = (long *) 0 ;
16813 long *arg3 = (long *) 0 ;
16814 long temp2 ;
16815 int res2 = 0 ;
16816 long temp3 ;
16817 int res3 = 0 ;
16818 PyObject * obj0 = 0 ;
16819 char *kwnames[] = {
16820 (char *) "self", NULL
16821 };
16822
16823 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16824 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16827 if (SWIG_arg_fail(1)) SWIG_fail;
16828 {
16829 PyThreadState* __tstate = wxPyBeginAllowThreads();
16830 (arg1)->GetPosition(arg2,arg3);
16831
16832 wxPyEndAllowThreads(__tstate);
16833 if (PyErr_Occurred()) SWIG_fail;
16834 }
16835 Py_INCREF(Py_None); resultobj = Py_None;
16836 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16837 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16838 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16839 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16840 return resultobj;
16841 fail:
16842 return NULL;
16843 }
16844
16845
16846 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj;
16848 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16849 wxDC *arg2 = 0 ;
16850 wxPoint result;
16851 PyObject * obj0 = 0 ;
16852 PyObject * obj1 = 0 ;
16853 char *kwnames[] = {
16854 (char *) "self",(char *) "dc", NULL
16855 };
16856
16857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16862 if (SWIG_arg_fail(2)) SWIG_fail;
16863 if (arg2 == NULL) {
16864 SWIG_null_ref("wxDC");
16865 }
16866 if (SWIG_arg_fail(2)) SWIG_fail;
16867 }
16868 {
16869 PyThreadState* __tstate = wxPyBeginAllowThreads();
16870 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16871
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 {
16876 wxPoint * resultptr;
16877 resultptr = new wxPoint((wxPoint &)(result));
16878 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16879 }
16880 return resultobj;
16881 fail:
16882 return NULL;
16883 }
16884
16885
16886 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16887 PyObject *resultobj;
16888 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16889 int result;
16890 PyObject * obj0 = 0 ;
16891 char *kwnames[] = {
16892 (char *) "self", NULL
16893 };
16894
16895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16897 if (SWIG_arg_fail(1)) SWIG_fail;
16898 {
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 result = (int)((wxMouseEvent const *)arg1)->GetX();
16901
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 {
16906 resultobj = SWIG_From_int((int)(result));
16907 }
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16915 PyObject *resultobj;
16916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16917 int result;
16918 PyObject * obj0 = 0 ;
16919 char *kwnames[] = {
16920 (char *) "self", NULL
16921 };
16922
16923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16925 if (SWIG_arg_fail(1)) SWIG_fail;
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 result = (int)((wxMouseEvent const *)arg1)->GetY();
16929
16930 wxPyEndAllowThreads(__tstate);
16931 if (PyErr_Occurred()) SWIG_fail;
16932 }
16933 {
16934 resultobj = SWIG_From_int((int)(result));
16935 }
16936 return resultobj;
16937 fail:
16938 return NULL;
16939 }
16940
16941
16942 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16943 PyObject *resultobj;
16944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16945 int result;
16946 PyObject * obj0 = 0 ;
16947 char *kwnames[] = {
16948 (char *) "self", NULL
16949 };
16950
16951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16953 if (SWIG_arg_fail(1)) SWIG_fail;
16954 {
16955 PyThreadState* __tstate = wxPyBeginAllowThreads();
16956 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16957
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 {
16962 resultobj = SWIG_From_int((int)(result));
16963 }
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16971 PyObject *resultobj;
16972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16973 int result;
16974 PyObject * obj0 = 0 ;
16975 char *kwnames[] = {
16976 (char *) "self", NULL
16977 };
16978
16979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16981 if (SWIG_arg_fail(1)) SWIG_fail;
16982 {
16983 PyThreadState* __tstate = wxPyBeginAllowThreads();
16984 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16985
16986 wxPyEndAllowThreads(__tstate);
16987 if (PyErr_Occurred()) SWIG_fail;
16988 }
16989 {
16990 resultobj = SWIG_From_int((int)(result));
16991 }
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16999 PyObject *resultobj;
17000 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17001 int result;
17002 PyObject * obj0 = 0 ;
17003 char *kwnames[] = {
17004 (char *) "self", NULL
17005 };
17006
17007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17009 if (SWIG_arg_fail(1)) SWIG_fail;
17010 {
17011 PyThreadState* __tstate = wxPyBeginAllowThreads();
17012 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17013
17014 wxPyEndAllowThreads(__tstate);
17015 if (PyErr_Occurred()) SWIG_fail;
17016 }
17017 {
17018 resultobj = SWIG_From_int((int)(result));
17019 }
17020 return resultobj;
17021 fail:
17022 return NULL;
17023 }
17024
17025
17026 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17027 PyObject *resultobj;
17028 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17029 bool result;
17030 PyObject * obj0 = 0 ;
17031 char *kwnames[] = {
17032 (char *) "self", NULL
17033 };
17034
17035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17037 if (SWIG_arg_fail(1)) SWIG_fail;
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17041
17042 wxPyEndAllowThreads(__tstate);
17043 if (PyErr_Occurred()) SWIG_fail;
17044 }
17045 {
17046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17047 }
17048 return resultobj;
17049 fail:
17050 return NULL;
17051 }
17052
17053
17054 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17055 PyObject *resultobj;
17056 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17057 int arg2 ;
17058 PyObject * obj0 = 0 ;
17059 PyObject * obj1 = 0 ;
17060 char *kwnames[] = {
17061 (char *) "self",(char *) "m_x", NULL
17062 };
17063
17064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17066 if (SWIG_arg_fail(1)) SWIG_fail;
17067 {
17068 arg2 = (int)(SWIG_As_int(obj1));
17069 if (SWIG_arg_fail(2)) SWIG_fail;
17070 }
17071 if (arg1) (arg1)->m_x = arg2;
17072
17073 Py_INCREF(Py_None); resultobj = Py_None;
17074 return resultobj;
17075 fail:
17076 return NULL;
17077 }
17078
17079
17080 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17081 PyObject *resultobj;
17082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17083 int result;
17084 PyObject * obj0 = 0 ;
17085 char *kwnames[] = {
17086 (char *) "self", NULL
17087 };
17088
17089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17091 if (SWIG_arg_fail(1)) SWIG_fail;
17092 result = (int) ((arg1)->m_x);
17093
17094 {
17095 resultobj = SWIG_From_int((int)(result));
17096 }
17097 return resultobj;
17098 fail:
17099 return NULL;
17100 }
17101
17102
17103 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17104 PyObject *resultobj;
17105 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17106 int arg2 ;
17107 PyObject * obj0 = 0 ;
17108 PyObject * obj1 = 0 ;
17109 char *kwnames[] = {
17110 (char *) "self",(char *) "m_y", NULL
17111 };
17112
17113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17115 if (SWIG_arg_fail(1)) SWIG_fail;
17116 {
17117 arg2 = (int)(SWIG_As_int(obj1));
17118 if (SWIG_arg_fail(2)) SWIG_fail;
17119 }
17120 if (arg1) (arg1)->m_y = arg2;
17121
17122 Py_INCREF(Py_None); resultobj = Py_None;
17123 return resultobj;
17124 fail:
17125 return NULL;
17126 }
17127
17128
17129 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj;
17131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17132 int result;
17133 PyObject * obj0 = 0 ;
17134 char *kwnames[] = {
17135 (char *) "self", NULL
17136 };
17137
17138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17140 if (SWIG_arg_fail(1)) SWIG_fail;
17141 result = (int) ((arg1)->m_y);
17142
17143 {
17144 resultobj = SWIG_From_int((int)(result));
17145 }
17146 return resultobj;
17147 fail:
17148 return NULL;
17149 }
17150
17151
17152 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj;
17154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17155 bool arg2 ;
17156 PyObject * obj0 = 0 ;
17157 PyObject * obj1 = 0 ;
17158 char *kwnames[] = {
17159 (char *) "self",(char *) "m_leftDown", NULL
17160 };
17161
17162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17164 if (SWIG_arg_fail(1)) SWIG_fail;
17165 {
17166 arg2 = (bool)(SWIG_As_bool(obj1));
17167 if (SWIG_arg_fail(2)) SWIG_fail;
17168 }
17169 if (arg1) (arg1)->m_leftDown = arg2;
17170
17171 Py_INCREF(Py_None); resultobj = Py_None;
17172 return resultobj;
17173 fail:
17174 return NULL;
17175 }
17176
17177
17178 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17179 PyObject *resultobj;
17180 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17181 bool result;
17182 PyObject * obj0 = 0 ;
17183 char *kwnames[] = {
17184 (char *) "self", NULL
17185 };
17186
17187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17189 if (SWIG_arg_fail(1)) SWIG_fail;
17190 result = (bool) ((arg1)->m_leftDown);
17191
17192 {
17193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17194 }
17195 return resultobj;
17196 fail:
17197 return NULL;
17198 }
17199
17200
17201 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17202 PyObject *resultobj;
17203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17204 bool arg2 ;
17205 PyObject * obj0 = 0 ;
17206 PyObject * obj1 = 0 ;
17207 char *kwnames[] = {
17208 (char *) "self",(char *) "m_middleDown", NULL
17209 };
17210
17211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17213 if (SWIG_arg_fail(1)) SWIG_fail;
17214 {
17215 arg2 = (bool)(SWIG_As_bool(obj1));
17216 if (SWIG_arg_fail(2)) SWIG_fail;
17217 }
17218 if (arg1) (arg1)->m_middleDown = arg2;
17219
17220 Py_INCREF(Py_None); resultobj = Py_None;
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj;
17229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17230 bool result;
17231 PyObject * obj0 = 0 ;
17232 char *kwnames[] = {
17233 (char *) "self", NULL
17234 };
17235
17236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17238 if (SWIG_arg_fail(1)) SWIG_fail;
17239 result = (bool) ((arg1)->m_middleDown);
17240
17241 {
17242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17243 }
17244 return resultobj;
17245 fail:
17246 return NULL;
17247 }
17248
17249
17250 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17251 PyObject *resultobj;
17252 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17253 bool arg2 ;
17254 PyObject * obj0 = 0 ;
17255 PyObject * obj1 = 0 ;
17256 char *kwnames[] = {
17257 (char *) "self",(char *) "m_rightDown", NULL
17258 };
17259
17260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17262 if (SWIG_arg_fail(1)) SWIG_fail;
17263 {
17264 arg2 = (bool)(SWIG_As_bool(obj1));
17265 if (SWIG_arg_fail(2)) SWIG_fail;
17266 }
17267 if (arg1) (arg1)->m_rightDown = arg2;
17268
17269 Py_INCREF(Py_None); resultobj = Py_None;
17270 return resultobj;
17271 fail:
17272 return NULL;
17273 }
17274
17275
17276 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17277 PyObject *resultobj;
17278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17279 bool result;
17280 PyObject * obj0 = 0 ;
17281 char *kwnames[] = {
17282 (char *) "self", NULL
17283 };
17284
17285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17287 if (SWIG_arg_fail(1)) SWIG_fail;
17288 result = (bool) ((arg1)->m_rightDown);
17289
17290 {
17291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17292 }
17293 return resultobj;
17294 fail:
17295 return NULL;
17296 }
17297
17298
17299 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17300 PyObject *resultobj;
17301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17302 bool arg2 ;
17303 PyObject * obj0 = 0 ;
17304 PyObject * obj1 = 0 ;
17305 char *kwnames[] = {
17306 (char *) "self",(char *) "m_controlDown", NULL
17307 };
17308
17309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17311 if (SWIG_arg_fail(1)) SWIG_fail;
17312 {
17313 arg2 = (bool)(SWIG_As_bool(obj1));
17314 if (SWIG_arg_fail(2)) SWIG_fail;
17315 }
17316 if (arg1) (arg1)->m_controlDown = arg2;
17317
17318 Py_INCREF(Py_None); resultobj = Py_None;
17319 return resultobj;
17320 fail:
17321 return NULL;
17322 }
17323
17324
17325 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17326 PyObject *resultobj;
17327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17328 bool result;
17329 PyObject * obj0 = 0 ;
17330 char *kwnames[] = {
17331 (char *) "self", NULL
17332 };
17333
17334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17336 if (SWIG_arg_fail(1)) SWIG_fail;
17337 result = (bool) ((arg1)->m_controlDown);
17338
17339 {
17340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17341 }
17342 return resultobj;
17343 fail:
17344 return NULL;
17345 }
17346
17347
17348 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17349 PyObject *resultobj;
17350 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17351 bool arg2 ;
17352 PyObject * obj0 = 0 ;
17353 PyObject * obj1 = 0 ;
17354 char *kwnames[] = {
17355 (char *) "self",(char *) "m_shiftDown", NULL
17356 };
17357
17358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17360 if (SWIG_arg_fail(1)) SWIG_fail;
17361 {
17362 arg2 = (bool)(SWIG_As_bool(obj1));
17363 if (SWIG_arg_fail(2)) SWIG_fail;
17364 }
17365 if (arg1) (arg1)->m_shiftDown = arg2;
17366
17367 Py_INCREF(Py_None); resultobj = Py_None;
17368 return resultobj;
17369 fail:
17370 return NULL;
17371 }
17372
17373
17374 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17375 PyObject *resultobj;
17376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17377 bool result;
17378 PyObject * obj0 = 0 ;
17379 char *kwnames[] = {
17380 (char *) "self", NULL
17381 };
17382
17383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17385 if (SWIG_arg_fail(1)) SWIG_fail;
17386 result = (bool) ((arg1)->m_shiftDown);
17387
17388 {
17389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17390 }
17391 return resultobj;
17392 fail:
17393 return NULL;
17394 }
17395
17396
17397 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17398 PyObject *resultobj;
17399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17400 bool arg2 ;
17401 PyObject * obj0 = 0 ;
17402 PyObject * obj1 = 0 ;
17403 char *kwnames[] = {
17404 (char *) "self",(char *) "m_altDown", NULL
17405 };
17406
17407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17409 if (SWIG_arg_fail(1)) SWIG_fail;
17410 {
17411 arg2 = (bool)(SWIG_As_bool(obj1));
17412 if (SWIG_arg_fail(2)) SWIG_fail;
17413 }
17414 if (arg1) (arg1)->m_altDown = arg2;
17415
17416 Py_INCREF(Py_None); resultobj = Py_None;
17417 return resultobj;
17418 fail:
17419 return NULL;
17420 }
17421
17422
17423 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17424 PyObject *resultobj;
17425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17426 bool result;
17427 PyObject * obj0 = 0 ;
17428 char *kwnames[] = {
17429 (char *) "self", NULL
17430 };
17431
17432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17434 if (SWIG_arg_fail(1)) SWIG_fail;
17435 result = (bool) ((arg1)->m_altDown);
17436
17437 {
17438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17439 }
17440 return resultobj;
17441 fail:
17442 return NULL;
17443 }
17444
17445
17446 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17447 PyObject *resultobj;
17448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17449 bool arg2 ;
17450 PyObject * obj0 = 0 ;
17451 PyObject * obj1 = 0 ;
17452 char *kwnames[] = {
17453 (char *) "self",(char *) "m_metaDown", NULL
17454 };
17455
17456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17458 if (SWIG_arg_fail(1)) SWIG_fail;
17459 {
17460 arg2 = (bool)(SWIG_As_bool(obj1));
17461 if (SWIG_arg_fail(2)) SWIG_fail;
17462 }
17463 if (arg1) (arg1)->m_metaDown = arg2;
17464
17465 Py_INCREF(Py_None); resultobj = Py_None;
17466 return resultobj;
17467 fail:
17468 return NULL;
17469 }
17470
17471
17472 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj;
17474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17475 bool result;
17476 PyObject * obj0 = 0 ;
17477 char *kwnames[] = {
17478 (char *) "self", NULL
17479 };
17480
17481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17483 if (SWIG_arg_fail(1)) SWIG_fail;
17484 result = (bool) ((arg1)->m_metaDown);
17485
17486 {
17487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17488 }
17489 return resultobj;
17490 fail:
17491 return NULL;
17492 }
17493
17494
17495 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17496 PyObject *resultobj;
17497 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17498 int arg2 ;
17499 PyObject * obj0 = 0 ;
17500 PyObject * obj1 = 0 ;
17501 char *kwnames[] = {
17502 (char *) "self",(char *) "m_wheelRotation", NULL
17503 };
17504
17505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17507 if (SWIG_arg_fail(1)) SWIG_fail;
17508 {
17509 arg2 = (int)(SWIG_As_int(obj1));
17510 if (SWIG_arg_fail(2)) SWIG_fail;
17511 }
17512 if (arg1) (arg1)->m_wheelRotation = arg2;
17513
17514 Py_INCREF(Py_None); resultobj = Py_None;
17515 return resultobj;
17516 fail:
17517 return NULL;
17518 }
17519
17520
17521 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17522 PyObject *resultobj;
17523 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17524 int result;
17525 PyObject * obj0 = 0 ;
17526 char *kwnames[] = {
17527 (char *) "self", NULL
17528 };
17529
17530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17532 if (SWIG_arg_fail(1)) SWIG_fail;
17533 result = (int) ((arg1)->m_wheelRotation);
17534
17535 {
17536 resultobj = SWIG_From_int((int)(result));
17537 }
17538 return resultobj;
17539 fail:
17540 return NULL;
17541 }
17542
17543
17544 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17545 PyObject *resultobj;
17546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17547 int arg2 ;
17548 PyObject * obj0 = 0 ;
17549 PyObject * obj1 = 0 ;
17550 char *kwnames[] = {
17551 (char *) "self",(char *) "m_wheelDelta", NULL
17552 };
17553
17554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17556 if (SWIG_arg_fail(1)) SWIG_fail;
17557 {
17558 arg2 = (int)(SWIG_As_int(obj1));
17559 if (SWIG_arg_fail(2)) SWIG_fail;
17560 }
17561 if (arg1) (arg1)->m_wheelDelta = arg2;
17562
17563 Py_INCREF(Py_None); resultobj = Py_None;
17564 return resultobj;
17565 fail:
17566 return NULL;
17567 }
17568
17569
17570 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17571 PyObject *resultobj;
17572 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17573 int result;
17574 PyObject * obj0 = 0 ;
17575 char *kwnames[] = {
17576 (char *) "self", NULL
17577 };
17578
17579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17581 if (SWIG_arg_fail(1)) SWIG_fail;
17582 result = (int) ((arg1)->m_wheelDelta);
17583
17584 {
17585 resultobj = SWIG_From_int((int)(result));
17586 }
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17594 PyObject *resultobj;
17595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17596 int arg2 ;
17597 PyObject * obj0 = 0 ;
17598 PyObject * obj1 = 0 ;
17599 char *kwnames[] = {
17600 (char *) "self",(char *) "m_linesPerAction", NULL
17601 };
17602
17603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17605 if (SWIG_arg_fail(1)) SWIG_fail;
17606 {
17607 arg2 = (int)(SWIG_As_int(obj1));
17608 if (SWIG_arg_fail(2)) SWIG_fail;
17609 }
17610 if (arg1) (arg1)->m_linesPerAction = arg2;
17611
17612 Py_INCREF(Py_None); resultobj = Py_None;
17613 return resultobj;
17614 fail:
17615 return NULL;
17616 }
17617
17618
17619 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17620 PyObject *resultobj;
17621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17622 int result;
17623 PyObject * obj0 = 0 ;
17624 char *kwnames[] = {
17625 (char *) "self", NULL
17626 };
17627
17628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17630 if (SWIG_arg_fail(1)) SWIG_fail;
17631 result = (int) ((arg1)->m_linesPerAction);
17632
17633 {
17634 resultobj = SWIG_From_int((int)(result));
17635 }
17636 return resultobj;
17637 fail:
17638 return NULL;
17639 }
17640
17641
17642 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17643 PyObject *obj;
17644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17645 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17646 Py_INCREF(obj);
17647 return Py_BuildValue((char *)"");
17648 }
17649 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17650 PyObject *resultobj;
17651 int arg1 = (int) 0 ;
17652 int arg2 = (int) 0 ;
17653 wxSetCursorEvent *result;
17654 PyObject * obj0 = 0 ;
17655 PyObject * obj1 = 0 ;
17656 char *kwnames[] = {
17657 (char *) "x",(char *) "y", NULL
17658 };
17659
17660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17661 if (obj0) {
17662 {
17663 arg1 = (int)(SWIG_As_int(obj0));
17664 if (SWIG_arg_fail(1)) SWIG_fail;
17665 }
17666 }
17667 if (obj1) {
17668 {
17669 arg2 = (int)(SWIG_As_int(obj1));
17670 if (SWIG_arg_fail(2)) SWIG_fail;
17671 }
17672 }
17673 {
17674 PyThreadState* __tstate = wxPyBeginAllowThreads();
17675 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17676
17677 wxPyEndAllowThreads(__tstate);
17678 if (PyErr_Occurred()) SWIG_fail;
17679 }
17680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17681 return resultobj;
17682 fail:
17683 return NULL;
17684 }
17685
17686
17687 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17688 PyObject *resultobj;
17689 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17690 int result;
17691 PyObject * obj0 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "self", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17698 if (SWIG_arg_fail(1)) SWIG_fail;
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17702
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 {
17707 resultobj = SWIG_From_int((int)(result));
17708 }
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj;
17717 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17718 int result;
17719 PyObject * obj0 = 0 ;
17720 char *kwnames[] = {
17721 (char *) "self", NULL
17722 };
17723
17724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17726 if (SWIG_arg_fail(1)) SWIG_fail;
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17730
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 {
17735 resultobj = SWIG_From_int((int)(result));
17736 }
17737 return resultobj;
17738 fail:
17739 return NULL;
17740 }
17741
17742
17743 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17744 PyObject *resultobj;
17745 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17746 wxCursor *arg2 = 0 ;
17747 PyObject * obj0 = 0 ;
17748 PyObject * obj1 = 0 ;
17749 char *kwnames[] = {
17750 (char *) "self",(char *) "cursor", NULL
17751 };
17752
17753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17755 if (SWIG_arg_fail(1)) SWIG_fail;
17756 {
17757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17758 if (SWIG_arg_fail(2)) SWIG_fail;
17759 if (arg2 == NULL) {
17760 SWIG_null_ref("wxCursor");
17761 }
17762 if (SWIG_arg_fail(2)) SWIG_fail;
17763 }
17764 {
17765 PyThreadState* __tstate = wxPyBeginAllowThreads();
17766 (arg1)->SetCursor((wxCursor const &)*arg2);
17767
17768 wxPyEndAllowThreads(__tstate);
17769 if (PyErr_Occurred()) SWIG_fail;
17770 }
17771 Py_INCREF(Py_None); resultobj = Py_None;
17772 return resultobj;
17773 fail:
17774 return NULL;
17775 }
17776
17777
17778 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17779 PyObject *resultobj;
17780 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17781 wxCursor *result;
17782 PyObject * obj0 = 0 ;
17783 char *kwnames[] = {
17784 (char *) "self", NULL
17785 };
17786
17787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17789 if (SWIG_arg_fail(1)) SWIG_fail;
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 {
17793 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17794 result = (wxCursor *) &_result_ref;
17795 }
17796
17797 wxPyEndAllowThreads(__tstate);
17798 if (PyErr_Occurred()) SWIG_fail;
17799 }
17800 {
17801 wxCursor* resultptr = new wxCursor(*result);
17802 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17803 }
17804 return resultobj;
17805 fail:
17806 return NULL;
17807 }
17808
17809
17810 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17811 PyObject *resultobj;
17812 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17813 bool result;
17814 PyObject * obj0 = 0 ;
17815 char *kwnames[] = {
17816 (char *) "self", NULL
17817 };
17818
17819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17821 if (SWIG_arg_fail(1)) SWIG_fail;
17822 {
17823 PyThreadState* __tstate = wxPyBeginAllowThreads();
17824 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17825
17826 wxPyEndAllowThreads(__tstate);
17827 if (PyErr_Occurred()) SWIG_fail;
17828 }
17829 {
17830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17831 }
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17839 PyObject *obj;
17840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17841 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17842 Py_INCREF(obj);
17843 return Py_BuildValue((char *)"");
17844 }
17845 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17846 PyObject *resultobj;
17847 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17848 wxKeyEvent *result;
17849 PyObject * obj0 = 0 ;
17850 char *kwnames[] = {
17851 (char *) "keyType", NULL
17852 };
17853
17854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17855 if (obj0) {
17856 {
17857 arg1 = (wxEventType)(SWIG_As_int(obj0));
17858 if (SWIG_arg_fail(1)) SWIG_fail;
17859 }
17860 }
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17864
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17876 PyObject *resultobj;
17877 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17878 bool result;
17879 PyObject * obj0 = 0 ;
17880 char *kwnames[] = {
17881 (char *) "self", NULL
17882 };
17883
17884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17886 if (SWIG_arg_fail(1)) SWIG_fail;
17887 {
17888 PyThreadState* __tstate = wxPyBeginAllowThreads();
17889 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17890
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 {
17895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17896 }
17897 return resultobj;
17898 fail:
17899 return NULL;
17900 }
17901
17902
17903 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17904 PyObject *resultobj;
17905 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17906 bool result;
17907 PyObject * obj0 = 0 ;
17908 char *kwnames[] = {
17909 (char *) "self", NULL
17910 };
17911
17912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17914 if (SWIG_arg_fail(1)) SWIG_fail;
17915 {
17916 PyThreadState* __tstate = wxPyBeginAllowThreads();
17917 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17918
17919 wxPyEndAllowThreads(__tstate);
17920 if (PyErr_Occurred()) SWIG_fail;
17921 }
17922 {
17923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17924 }
17925 return resultobj;
17926 fail:
17927 return NULL;
17928 }
17929
17930
17931 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17932 PyObject *resultobj;
17933 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17934 bool result;
17935 PyObject * obj0 = 0 ;
17936 char *kwnames[] = {
17937 (char *) "self", NULL
17938 };
17939
17940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17942 if (SWIG_arg_fail(1)) SWIG_fail;
17943 {
17944 PyThreadState* __tstate = wxPyBeginAllowThreads();
17945 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17946
17947 wxPyEndAllowThreads(__tstate);
17948 if (PyErr_Occurred()) SWIG_fail;
17949 }
17950 {
17951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17952 }
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj;
17961 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17962 bool result;
17963 PyObject * obj0 = 0 ;
17964 char *kwnames[] = {
17965 (char *) "self", NULL
17966 };
17967
17968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17970 if (SWIG_arg_fail(1)) SWIG_fail;
17971 {
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17974
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 {
17979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17980 }
17981 return resultobj;
17982 fail:
17983 return NULL;
17984 }
17985
17986
17987 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17988 PyObject *resultobj;
17989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17990 bool result;
17991 PyObject * obj0 = 0 ;
17992 char *kwnames[] = {
17993 (char *) "self", NULL
17994 };
17995
17996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17998 if (SWIG_arg_fail(1)) SWIG_fail;
17999 {
18000 PyThreadState* __tstate = wxPyBeginAllowThreads();
18001 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18002
18003 wxPyEndAllowThreads(__tstate);
18004 if (PyErr_Occurred()) SWIG_fail;
18005 }
18006 {
18007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18008 }
18009 return resultobj;
18010 fail:
18011 return NULL;
18012 }
18013
18014
18015 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18016 PyObject *resultobj;
18017 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18018 bool result;
18019 PyObject * obj0 = 0 ;
18020 char *kwnames[] = {
18021 (char *) "self", NULL
18022 };
18023
18024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18026 if (SWIG_arg_fail(1)) SWIG_fail;
18027 {
18028 PyThreadState* __tstate = wxPyBeginAllowThreads();
18029 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18030
18031 wxPyEndAllowThreads(__tstate);
18032 if (PyErr_Occurred()) SWIG_fail;
18033 }
18034 {
18035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18036 }
18037 return resultobj;
18038 fail:
18039 return NULL;
18040 }
18041
18042
18043 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18044 PyObject *resultobj;
18045 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18046 int result;
18047 PyObject * obj0 = 0 ;
18048 char *kwnames[] = {
18049 (char *) "self", NULL
18050 };
18051
18052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18054 if (SWIG_arg_fail(1)) SWIG_fail;
18055 {
18056 PyThreadState* __tstate = wxPyBeginAllowThreads();
18057 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18058
18059 wxPyEndAllowThreads(__tstate);
18060 if (PyErr_Occurred()) SWIG_fail;
18061 }
18062 {
18063 resultobj = SWIG_From_int((int)(result));
18064 }
18065 return resultobj;
18066 fail:
18067 return NULL;
18068 }
18069
18070
18071 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18072 PyObject *resultobj;
18073 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18074 int result;
18075 PyObject * obj0 = 0 ;
18076 char *kwnames[] = {
18077 (char *) "self", NULL
18078 };
18079
18080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18082 if (SWIG_arg_fail(1)) SWIG_fail;
18083 {
18084 PyThreadState* __tstate = wxPyBeginAllowThreads();
18085 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18086
18087 wxPyEndAllowThreads(__tstate);
18088 if (PyErr_Occurred()) SWIG_fail;
18089 }
18090 {
18091 resultobj = SWIG_From_int((int)(result));
18092 }
18093 return resultobj;
18094 fail:
18095 return NULL;
18096 }
18097
18098
18099 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18100 PyObject *resultobj;
18101 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18102 unsigned int result;
18103 PyObject * obj0 = 0 ;
18104 char *kwnames[] = {
18105 (char *) "self", NULL
18106 };
18107
18108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18110 if (SWIG_arg_fail(1)) SWIG_fail;
18111 {
18112 PyThreadState* __tstate = wxPyBeginAllowThreads();
18113 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18114
18115 wxPyEndAllowThreads(__tstate);
18116 if (PyErr_Occurred()) SWIG_fail;
18117 }
18118 {
18119 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18120 }
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18128 PyObject *resultobj;
18129 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18130 unsigned int result;
18131 PyObject * obj0 = 0 ;
18132 char *kwnames[] = {
18133 (char *) "self", NULL
18134 };
18135
18136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18138 if (SWIG_arg_fail(1)) SWIG_fail;
18139 {
18140 PyThreadState* __tstate = wxPyBeginAllowThreads();
18141 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18142
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 {
18147 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18148 }
18149 return resultobj;
18150 fail:
18151 return NULL;
18152 }
18153
18154
18155 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18156 PyObject *resultobj;
18157 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18158 wxPoint result;
18159 PyObject * obj0 = 0 ;
18160 char *kwnames[] = {
18161 (char *) "self", NULL
18162 };
18163
18164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18166 if (SWIG_arg_fail(1)) SWIG_fail;
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 result = (arg1)->GetPosition();
18170
18171 wxPyEndAllowThreads(__tstate);
18172 if (PyErr_Occurred()) SWIG_fail;
18173 }
18174 {
18175 wxPoint * resultptr;
18176 resultptr = new wxPoint((wxPoint &)(result));
18177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18178 }
18179 return resultobj;
18180 fail:
18181 return NULL;
18182 }
18183
18184
18185 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18186 PyObject *resultobj;
18187 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18188 long *arg2 = (long *) 0 ;
18189 long *arg3 = (long *) 0 ;
18190 long temp2 ;
18191 int res2 = 0 ;
18192 long temp3 ;
18193 int res3 = 0 ;
18194 PyObject * obj0 = 0 ;
18195 char *kwnames[] = {
18196 (char *) "self", NULL
18197 };
18198
18199 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18200 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18203 if (SWIG_arg_fail(1)) SWIG_fail;
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 (arg1)->GetPosition(arg2,arg3);
18207
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 Py_INCREF(Py_None); resultobj = Py_None;
18212 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18213 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18214 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18215 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18216 return resultobj;
18217 fail:
18218 return NULL;
18219 }
18220
18221
18222 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18223 PyObject *resultobj;
18224 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18225 int result;
18226 PyObject * obj0 = 0 ;
18227 char *kwnames[] = {
18228 (char *) "self", NULL
18229 };
18230
18231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18233 if (SWIG_arg_fail(1)) SWIG_fail;
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 result = (int)((wxKeyEvent const *)arg1)->GetX();
18237
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 {
18242 resultobj = SWIG_From_int((int)(result));
18243 }
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj;
18252 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18253 int result;
18254 PyObject * obj0 = 0 ;
18255 char *kwnames[] = {
18256 (char *) "self", NULL
18257 };
18258
18259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18261 if (SWIG_arg_fail(1)) SWIG_fail;
18262 {
18263 PyThreadState* __tstate = wxPyBeginAllowThreads();
18264 result = (int)((wxKeyEvent const *)arg1)->GetY();
18265
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 {
18270 resultobj = SWIG_From_int((int)(result));
18271 }
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj;
18280 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18281 int arg2 ;
18282 PyObject * obj0 = 0 ;
18283 PyObject * obj1 = 0 ;
18284 char *kwnames[] = {
18285 (char *) "self",(char *) "m_x", NULL
18286 };
18287
18288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18290 if (SWIG_arg_fail(1)) SWIG_fail;
18291 {
18292 arg2 = (int)(SWIG_As_int(obj1));
18293 if (SWIG_arg_fail(2)) SWIG_fail;
18294 }
18295 if (arg1) (arg1)->m_x = arg2;
18296
18297 Py_INCREF(Py_None); resultobj = Py_None;
18298 return resultobj;
18299 fail:
18300 return NULL;
18301 }
18302
18303
18304 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18305 PyObject *resultobj;
18306 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18307 int result;
18308 PyObject * obj0 = 0 ;
18309 char *kwnames[] = {
18310 (char *) "self", NULL
18311 };
18312
18313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18315 if (SWIG_arg_fail(1)) SWIG_fail;
18316 result = (int) ((arg1)->m_x);
18317
18318 {
18319 resultobj = SWIG_From_int((int)(result));
18320 }
18321 return resultobj;
18322 fail:
18323 return NULL;
18324 }
18325
18326
18327 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18328 PyObject *resultobj;
18329 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18330 int arg2 ;
18331 PyObject * obj0 = 0 ;
18332 PyObject * obj1 = 0 ;
18333 char *kwnames[] = {
18334 (char *) "self",(char *) "m_y", NULL
18335 };
18336
18337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18339 if (SWIG_arg_fail(1)) SWIG_fail;
18340 {
18341 arg2 = (int)(SWIG_As_int(obj1));
18342 if (SWIG_arg_fail(2)) SWIG_fail;
18343 }
18344 if (arg1) (arg1)->m_y = arg2;
18345
18346 Py_INCREF(Py_None); resultobj = Py_None;
18347 return resultobj;
18348 fail:
18349 return NULL;
18350 }
18351
18352
18353 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18354 PyObject *resultobj;
18355 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18356 int result;
18357 PyObject * obj0 = 0 ;
18358 char *kwnames[] = {
18359 (char *) "self", NULL
18360 };
18361
18362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18364 if (SWIG_arg_fail(1)) SWIG_fail;
18365 result = (int) ((arg1)->m_y);
18366
18367 {
18368 resultobj = SWIG_From_int((int)(result));
18369 }
18370 return resultobj;
18371 fail:
18372 return NULL;
18373 }
18374
18375
18376 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18377 PyObject *resultobj;
18378 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18379 long arg2 ;
18380 PyObject * obj0 = 0 ;
18381 PyObject * obj1 = 0 ;
18382 char *kwnames[] = {
18383 (char *) "self",(char *) "m_keyCode", NULL
18384 };
18385
18386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18388 if (SWIG_arg_fail(1)) SWIG_fail;
18389 {
18390 arg2 = (long)(SWIG_As_long(obj1));
18391 if (SWIG_arg_fail(2)) SWIG_fail;
18392 }
18393 if (arg1) (arg1)->m_keyCode = arg2;
18394
18395 Py_INCREF(Py_None); resultobj = Py_None;
18396 return resultobj;
18397 fail:
18398 return NULL;
18399 }
18400
18401
18402 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18403 PyObject *resultobj;
18404 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18405 long result;
18406 PyObject * obj0 = 0 ;
18407 char *kwnames[] = {
18408 (char *) "self", NULL
18409 };
18410
18411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18413 if (SWIG_arg_fail(1)) SWIG_fail;
18414 result = (long) ((arg1)->m_keyCode);
18415
18416 {
18417 resultobj = SWIG_From_long((long)(result));
18418 }
18419 return resultobj;
18420 fail:
18421 return NULL;
18422 }
18423
18424
18425 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18426 PyObject *resultobj;
18427 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18428 bool arg2 ;
18429 PyObject * obj0 = 0 ;
18430 PyObject * obj1 = 0 ;
18431 char *kwnames[] = {
18432 (char *) "self",(char *) "m_controlDown", NULL
18433 };
18434
18435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18437 if (SWIG_arg_fail(1)) SWIG_fail;
18438 {
18439 arg2 = (bool)(SWIG_As_bool(obj1));
18440 if (SWIG_arg_fail(2)) SWIG_fail;
18441 }
18442 if (arg1) (arg1)->m_controlDown = arg2;
18443
18444 Py_INCREF(Py_None); resultobj = Py_None;
18445 return resultobj;
18446 fail:
18447 return NULL;
18448 }
18449
18450
18451 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18452 PyObject *resultobj;
18453 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18454 bool result;
18455 PyObject * obj0 = 0 ;
18456 char *kwnames[] = {
18457 (char *) "self", NULL
18458 };
18459
18460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18462 if (SWIG_arg_fail(1)) SWIG_fail;
18463 result = (bool) ((arg1)->m_controlDown);
18464
18465 {
18466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18467 }
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj;
18476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18477 bool arg2 ;
18478 PyObject * obj0 = 0 ;
18479 PyObject * obj1 = 0 ;
18480 char *kwnames[] = {
18481 (char *) "self",(char *) "m_shiftDown", NULL
18482 };
18483
18484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18486 if (SWIG_arg_fail(1)) SWIG_fail;
18487 {
18488 arg2 = (bool)(SWIG_As_bool(obj1));
18489 if (SWIG_arg_fail(2)) SWIG_fail;
18490 }
18491 if (arg1) (arg1)->m_shiftDown = arg2;
18492
18493 Py_INCREF(Py_None); resultobj = Py_None;
18494 return resultobj;
18495 fail:
18496 return NULL;
18497 }
18498
18499
18500 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18501 PyObject *resultobj;
18502 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18503 bool result;
18504 PyObject * obj0 = 0 ;
18505 char *kwnames[] = {
18506 (char *) "self", NULL
18507 };
18508
18509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18511 if (SWIG_arg_fail(1)) SWIG_fail;
18512 result = (bool) ((arg1)->m_shiftDown);
18513
18514 {
18515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18516 }
18517 return resultobj;
18518 fail:
18519 return NULL;
18520 }
18521
18522
18523 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18524 PyObject *resultobj;
18525 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18526 bool arg2 ;
18527 PyObject * obj0 = 0 ;
18528 PyObject * obj1 = 0 ;
18529 char *kwnames[] = {
18530 (char *) "self",(char *) "m_altDown", NULL
18531 };
18532
18533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18535 if (SWIG_arg_fail(1)) SWIG_fail;
18536 {
18537 arg2 = (bool)(SWIG_As_bool(obj1));
18538 if (SWIG_arg_fail(2)) SWIG_fail;
18539 }
18540 if (arg1) (arg1)->m_altDown = arg2;
18541
18542 Py_INCREF(Py_None); resultobj = Py_None;
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18550 PyObject *resultobj;
18551 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18552 bool result;
18553 PyObject * obj0 = 0 ;
18554 char *kwnames[] = {
18555 (char *) "self", NULL
18556 };
18557
18558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18560 if (SWIG_arg_fail(1)) SWIG_fail;
18561 result = (bool) ((arg1)->m_altDown);
18562
18563 {
18564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18565 }
18566 return resultobj;
18567 fail:
18568 return NULL;
18569 }
18570
18571
18572 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18573 PyObject *resultobj;
18574 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18575 bool arg2 ;
18576 PyObject * obj0 = 0 ;
18577 PyObject * obj1 = 0 ;
18578 char *kwnames[] = {
18579 (char *) "self",(char *) "m_metaDown", NULL
18580 };
18581
18582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18584 if (SWIG_arg_fail(1)) SWIG_fail;
18585 {
18586 arg2 = (bool)(SWIG_As_bool(obj1));
18587 if (SWIG_arg_fail(2)) SWIG_fail;
18588 }
18589 if (arg1) (arg1)->m_metaDown = arg2;
18590
18591 Py_INCREF(Py_None); resultobj = Py_None;
18592 return resultobj;
18593 fail:
18594 return NULL;
18595 }
18596
18597
18598 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18599 PyObject *resultobj;
18600 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18601 bool result;
18602 PyObject * obj0 = 0 ;
18603 char *kwnames[] = {
18604 (char *) "self", NULL
18605 };
18606
18607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18609 if (SWIG_arg_fail(1)) SWIG_fail;
18610 result = (bool) ((arg1)->m_metaDown);
18611
18612 {
18613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18614 }
18615 return resultobj;
18616 fail:
18617 return NULL;
18618 }
18619
18620
18621 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18622 PyObject *resultobj;
18623 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18624 bool arg2 ;
18625 PyObject * obj0 = 0 ;
18626 PyObject * obj1 = 0 ;
18627 char *kwnames[] = {
18628 (char *) "self",(char *) "m_scanCode", NULL
18629 };
18630
18631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18633 if (SWIG_arg_fail(1)) SWIG_fail;
18634 {
18635 arg2 = (bool)(SWIG_As_bool(obj1));
18636 if (SWIG_arg_fail(2)) SWIG_fail;
18637 }
18638 if (arg1) (arg1)->m_scanCode = arg2;
18639
18640 Py_INCREF(Py_None); resultobj = Py_None;
18641 return resultobj;
18642 fail:
18643 return NULL;
18644 }
18645
18646
18647 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18648 PyObject *resultobj;
18649 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18650 bool result;
18651 PyObject * obj0 = 0 ;
18652 char *kwnames[] = {
18653 (char *) "self", NULL
18654 };
18655
18656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18658 if (SWIG_arg_fail(1)) SWIG_fail;
18659 result = (bool) ((arg1)->m_scanCode);
18660
18661 {
18662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18663 }
18664 return resultobj;
18665 fail:
18666 return NULL;
18667 }
18668
18669
18670 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18671 PyObject *resultobj;
18672 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18673 unsigned int arg2 ;
18674 PyObject * obj0 = 0 ;
18675 PyObject * obj1 = 0 ;
18676 char *kwnames[] = {
18677 (char *) "self",(char *) "m_rawCode", NULL
18678 };
18679
18680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18682 if (SWIG_arg_fail(1)) SWIG_fail;
18683 {
18684 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18685 if (SWIG_arg_fail(2)) SWIG_fail;
18686 }
18687 if (arg1) (arg1)->m_rawCode = arg2;
18688
18689 Py_INCREF(Py_None); resultobj = Py_None;
18690 return resultobj;
18691 fail:
18692 return NULL;
18693 }
18694
18695
18696 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18697 PyObject *resultobj;
18698 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18699 unsigned int result;
18700 PyObject * obj0 = 0 ;
18701 char *kwnames[] = {
18702 (char *) "self", NULL
18703 };
18704
18705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18707 if (SWIG_arg_fail(1)) SWIG_fail;
18708 result = (unsigned int) ((arg1)->m_rawCode);
18709
18710 {
18711 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18712 }
18713 return resultobj;
18714 fail:
18715 return NULL;
18716 }
18717
18718
18719 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18720 PyObject *resultobj;
18721 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18722 unsigned int arg2 ;
18723 PyObject * obj0 = 0 ;
18724 PyObject * obj1 = 0 ;
18725 char *kwnames[] = {
18726 (char *) "self",(char *) "m_rawFlags", NULL
18727 };
18728
18729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18731 if (SWIG_arg_fail(1)) SWIG_fail;
18732 {
18733 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18734 if (SWIG_arg_fail(2)) SWIG_fail;
18735 }
18736 if (arg1) (arg1)->m_rawFlags = arg2;
18737
18738 Py_INCREF(Py_None); resultobj = Py_None;
18739 return resultobj;
18740 fail:
18741 return NULL;
18742 }
18743
18744
18745 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18746 PyObject *resultobj;
18747 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18748 unsigned int result;
18749 PyObject * obj0 = 0 ;
18750 char *kwnames[] = {
18751 (char *) "self", NULL
18752 };
18753
18754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18756 if (SWIG_arg_fail(1)) SWIG_fail;
18757 result = (unsigned int) ((arg1)->m_rawFlags);
18758
18759 {
18760 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18761 }
18762 return resultobj;
18763 fail:
18764 return NULL;
18765 }
18766
18767
18768 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18769 PyObject *obj;
18770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18771 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18772 Py_INCREF(obj);
18773 return Py_BuildValue((char *)"");
18774 }
18775 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18776 PyObject *resultobj;
18777 wxSize const &arg1_defvalue = wxDefaultSize ;
18778 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18779 int arg2 = (int) 0 ;
18780 wxSizeEvent *result;
18781 wxSize temp1 ;
18782 PyObject * obj0 = 0 ;
18783 PyObject * obj1 = 0 ;
18784 char *kwnames[] = {
18785 (char *) "sz",(char *) "winid", NULL
18786 };
18787
18788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18789 if (obj0) {
18790 {
18791 arg1 = &temp1;
18792 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18793 }
18794 }
18795 if (obj1) {
18796 {
18797 arg2 = (int)(SWIG_As_int(obj1));
18798 if (SWIG_arg_fail(2)) SWIG_fail;
18799 }
18800 }
18801 {
18802 PyThreadState* __tstate = wxPyBeginAllowThreads();
18803 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18804
18805 wxPyEndAllowThreads(__tstate);
18806 if (PyErr_Occurred()) SWIG_fail;
18807 }
18808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18809 return resultobj;
18810 fail:
18811 return NULL;
18812 }
18813
18814
18815 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18816 PyObject *resultobj;
18817 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18818 wxSize result;
18819 PyObject * obj0 = 0 ;
18820 char *kwnames[] = {
18821 (char *) "self", NULL
18822 };
18823
18824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18826 if (SWIG_arg_fail(1)) SWIG_fail;
18827 {
18828 PyThreadState* __tstate = wxPyBeginAllowThreads();
18829 result = ((wxSizeEvent const *)arg1)->GetSize();
18830
18831 wxPyEndAllowThreads(__tstate);
18832 if (PyErr_Occurred()) SWIG_fail;
18833 }
18834 {
18835 wxSize * resultptr;
18836 resultptr = new wxSize((wxSize &)(result));
18837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18838 }
18839 return resultobj;
18840 fail:
18841 return NULL;
18842 }
18843
18844
18845 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18846 PyObject *resultobj;
18847 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18848 wxRect result;
18849 PyObject * obj0 = 0 ;
18850 char *kwnames[] = {
18851 (char *) "self", NULL
18852 };
18853
18854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18856 if (SWIG_arg_fail(1)) SWIG_fail;
18857 {
18858 PyThreadState* __tstate = wxPyBeginAllowThreads();
18859 result = ((wxSizeEvent const *)arg1)->GetRect();
18860
18861 wxPyEndAllowThreads(__tstate);
18862 if (PyErr_Occurred()) SWIG_fail;
18863 }
18864 {
18865 wxRect * resultptr;
18866 resultptr = new wxRect((wxRect &)(result));
18867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18868 }
18869 return resultobj;
18870 fail:
18871 return NULL;
18872 }
18873
18874
18875 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18876 PyObject *resultobj;
18877 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18878 wxRect arg2 ;
18879 PyObject * obj0 = 0 ;
18880 PyObject * obj1 = 0 ;
18881 char *kwnames[] = {
18882 (char *) "self",(char *) "rect", NULL
18883 };
18884
18885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18887 if (SWIG_arg_fail(1)) SWIG_fail;
18888 {
18889 wxRect * argp;
18890 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18891 if (SWIG_arg_fail(2)) SWIG_fail;
18892 if (argp == NULL) {
18893 SWIG_null_ref("wxRect");
18894 }
18895 if (SWIG_arg_fail(2)) SWIG_fail;
18896 arg2 = *argp;
18897 }
18898 {
18899 PyThreadState* __tstate = wxPyBeginAllowThreads();
18900 (arg1)->SetRect(arg2);
18901
18902 wxPyEndAllowThreads(__tstate);
18903 if (PyErr_Occurred()) SWIG_fail;
18904 }
18905 Py_INCREF(Py_None); resultobj = Py_None;
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj;
18914 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18915 wxSize arg2 ;
18916 PyObject * obj0 = 0 ;
18917 PyObject * obj1 = 0 ;
18918 char *kwnames[] = {
18919 (char *) "self",(char *) "size", NULL
18920 };
18921
18922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18924 if (SWIG_arg_fail(1)) SWIG_fail;
18925 {
18926 wxSize * argp;
18927 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18928 if (SWIG_arg_fail(2)) SWIG_fail;
18929 if (argp == NULL) {
18930 SWIG_null_ref("wxSize");
18931 }
18932 if (SWIG_arg_fail(2)) SWIG_fail;
18933 arg2 = *argp;
18934 }
18935 {
18936 PyThreadState* __tstate = wxPyBeginAllowThreads();
18937 wxSizeEvent_SetSize(arg1,arg2);
18938
18939 wxPyEndAllowThreads(__tstate);
18940 if (PyErr_Occurred()) SWIG_fail;
18941 }
18942 Py_INCREF(Py_None); resultobj = Py_None;
18943 return resultobj;
18944 fail:
18945 return NULL;
18946 }
18947
18948
18949 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18950 PyObject *resultobj;
18951 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18952 wxSize *arg2 = (wxSize *) 0 ;
18953 PyObject * obj0 = 0 ;
18954 PyObject * obj1 = 0 ;
18955 char *kwnames[] = {
18956 (char *) "self",(char *) "m_size", NULL
18957 };
18958
18959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18961 if (SWIG_arg_fail(1)) SWIG_fail;
18962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18963 if (SWIG_arg_fail(2)) SWIG_fail;
18964 if (arg1) (arg1)->m_size = *arg2;
18965
18966 Py_INCREF(Py_None); resultobj = Py_None;
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18974 PyObject *resultobj;
18975 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18976 wxSize *result;
18977 PyObject * obj0 = 0 ;
18978 char *kwnames[] = {
18979 (char *) "self", NULL
18980 };
18981
18982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18984 if (SWIG_arg_fail(1)) SWIG_fail;
18985 result = (wxSize *)& ((arg1)->m_size);
18986
18987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj;
18996 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18997 wxRect *arg2 = (wxRect *) 0 ;
18998 PyObject * obj0 = 0 ;
18999 PyObject * obj1 = 0 ;
19000 char *kwnames[] = {
19001 (char *) "self",(char *) "m_rect", NULL
19002 };
19003
19004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19006 if (SWIG_arg_fail(1)) SWIG_fail;
19007 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19008 if (SWIG_arg_fail(2)) SWIG_fail;
19009 if (arg1) (arg1)->m_rect = *arg2;
19010
19011 Py_INCREF(Py_None); resultobj = Py_None;
19012 return resultobj;
19013 fail:
19014 return NULL;
19015 }
19016
19017
19018 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19019 PyObject *resultobj;
19020 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19021 wxRect *result;
19022 PyObject * obj0 = 0 ;
19023 char *kwnames[] = {
19024 (char *) "self", NULL
19025 };
19026
19027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19029 if (SWIG_arg_fail(1)) SWIG_fail;
19030 result = (wxRect *)& ((arg1)->m_rect);
19031
19032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19033 return resultobj;
19034 fail:
19035 return NULL;
19036 }
19037
19038
19039 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19040 PyObject *obj;
19041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19042 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19043 Py_INCREF(obj);
19044 return Py_BuildValue((char *)"");
19045 }
19046 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj;
19048 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19049 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19050 int arg2 = (int) 0 ;
19051 wxMoveEvent *result;
19052 wxPoint temp1 ;
19053 PyObject * obj0 = 0 ;
19054 PyObject * obj1 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "pos",(char *) "winid", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19060 if (obj0) {
19061 {
19062 arg1 = &temp1;
19063 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19064 }
19065 }
19066 if (obj1) {
19067 {
19068 arg2 = (int)(SWIG_As_int(obj1));
19069 if (SWIG_arg_fail(2)) SWIG_fail;
19070 }
19071 }
19072 {
19073 PyThreadState* __tstate = wxPyBeginAllowThreads();
19074 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19075
19076 wxPyEndAllowThreads(__tstate);
19077 if (PyErr_Occurred()) SWIG_fail;
19078 }
19079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19080 return resultobj;
19081 fail:
19082 return NULL;
19083 }
19084
19085
19086 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19087 PyObject *resultobj;
19088 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19089 wxPoint result;
19090 PyObject * obj0 = 0 ;
19091 char *kwnames[] = {
19092 (char *) "self", NULL
19093 };
19094
19095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19097 if (SWIG_arg_fail(1)) SWIG_fail;
19098 {
19099 PyThreadState* __tstate = wxPyBeginAllowThreads();
19100 result = ((wxMoveEvent const *)arg1)->GetPosition();
19101
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 {
19106 wxPoint * resultptr;
19107 resultptr = new wxPoint((wxPoint &)(result));
19108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19109 }
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19117 PyObject *resultobj;
19118 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19119 wxRect result;
19120 PyObject * obj0 = 0 ;
19121 char *kwnames[] = {
19122 (char *) "self", NULL
19123 };
19124
19125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19127 if (SWIG_arg_fail(1)) SWIG_fail;
19128 {
19129 PyThreadState* __tstate = wxPyBeginAllowThreads();
19130 result = ((wxMoveEvent const *)arg1)->GetRect();
19131
19132 wxPyEndAllowThreads(__tstate);
19133 if (PyErr_Occurred()) SWIG_fail;
19134 }
19135 {
19136 wxRect * resultptr;
19137 resultptr = new wxRect((wxRect &)(result));
19138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19139 }
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19147 PyObject *resultobj;
19148 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19149 wxRect *arg2 = 0 ;
19150 wxRect temp2 ;
19151 PyObject * obj0 = 0 ;
19152 PyObject * obj1 = 0 ;
19153 char *kwnames[] = {
19154 (char *) "self",(char *) "rect", NULL
19155 };
19156
19157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19159 if (SWIG_arg_fail(1)) SWIG_fail;
19160 {
19161 arg2 = &temp2;
19162 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19163 }
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 (arg1)->SetRect((wxRect const &)*arg2);
19167
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 Py_INCREF(Py_None); resultobj = Py_None;
19172 return resultobj;
19173 fail:
19174 return NULL;
19175 }
19176
19177
19178 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19179 PyObject *resultobj;
19180 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19181 wxPoint *arg2 = 0 ;
19182 wxPoint temp2 ;
19183 PyObject * obj0 = 0 ;
19184 PyObject * obj1 = 0 ;
19185 char *kwnames[] = {
19186 (char *) "self",(char *) "pos", NULL
19187 };
19188
19189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19191 if (SWIG_arg_fail(1)) SWIG_fail;
19192 {
19193 arg2 = &temp2;
19194 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19195 }
19196 {
19197 PyThreadState* __tstate = wxPyBeginAllowThreads();
19198 (arg1)->SetPosition((wxPoint const &)*arg2);
19199
19200 wxPyEndAllowThreads(__tstate);
19201 if (PyErr_Occurred()) SWIG_fail;
19202 }
19203 Py_INCREF(Py_None); resultobj = Py_None;
19204 return resultobj;
19205 fail:
19206 return NULL;
19207 }
19208
19209
19210 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19211 PyObject *obj;
19212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19213 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19214 Py_INCREF(obj);
19215 return Py_BuildValue((char *)"");
19216 }
19217 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19218 PyObject *resultobj;
19219 int arg1 = (int) 0 ;
19220 wxPaintEvent *result;
19221 PyObject * obj0 = 0 ;
19222 char *kwnames[] = {
19223 (char *) "Id", NULL
19224 };
19225
19226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19227 if (obj0) {
19228 {
19229 arg1 = (int)(SWIG_As_int(obj0));
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 }
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19236
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19241 return resultobj;
19242 fail:
19243 return NULL;
19244 }
19245
19246
19247 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19248 PyObject *obj;
19249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19250 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19251 Py_INCREF(obj);
19252 return Py_BuildValue((char *)"");
19253 }
19254 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19255 PyObject *resultobj;
19256 int arg1 = (int) 0 ;
19257 wxNcPaintEvent *result;
19258 PyObject * obj0 = 0 ;
19259 char *kwnames[] = {
19260 (char *) "winid", NULL
19261 };
19262
19263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19264 if (obj0) {
19265 {
19266 arg1 = (int)(SWIG_As_int(obj0));
19267 if (SWIG_arg_fail(1)) SWIG_fail;
19268 }
19269 }
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19273
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19285 PyObject *obj;
19286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19287 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19288 Py_INCREF(obj);
19289 return Py_BuildValue((char *)"");
19290 }
19291 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19292 PyObject *resultobj;
19293 int arg1 = (int) 0 ;
19294 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19295 wxEraseEvent *result;
19296 PyObject * obj0 = 0 ;
19297 PyObject * obj1 = 0 ;
19298 char *kwnames[] = {
19299 (char *) "Id",(char *) "dc", NULL
19300 };
19301
19302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19303 if (obj0) {
19304 {
19305 arg1 = (int)(SWIG_As_int(obj0));
19306 if (SWIG_arg_fail(1)) SWIG_fail;
19307 }
19308 }
19309 if (obj1) {
19310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19311 if (SWIG_arg_fail(2)) SWIG_fail;
19312 }
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19316
19317 wxPyEndAllowThreads(__tstate);
19318 if (PyErr_Occurred()) SWIG_fail;
19319 }
19320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19321 return resultobj;
19322 fail:
19323 return NULL;
19324 }
19325
19326
19327 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19328 PyObject *resultobj;
19329 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19330 wxDC *result;
19331 PyObject * obj0 = 0 ;
19332 char *kwnames[] = {
19333 (char *) "self", NULL
19334 };
19335
19336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19338 if (SWIG_arg_fail(1)) SWIG_fail;
19339 {
19340 PyThreadState* __tstate = wxPyBeginAllowThreads();
19341 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19342
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 {
19347 resultobj = wxPyMake_wxObject(result, 0);
19348 }
19349 return resultobj;
19350 fail:
19351 return NULL;
19352 }
19353
19354
19355 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19356 PyObject *obj;
19357 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19358 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19359 Py_INCREF(obj);
19360 return Py_BuildValue((char *)"");
19361 }
19362 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19365 int arg2 = (int) 0 ;
19366 wxFocusEvent *result;
19367 PyObject * obj0 = 0 ;
19368 PyObject * obj1 = 0 ;
19369 char *kwnames[] = {
19370 (char *) "type",(char *) "winid", NULL
19371 };
19372
19373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19374 if (obj0) {
19375 {
19376 arg1 = (wxEventType)(SWIG_As_int(obj0));
19377 if (SWIG_arg_fail(1)) SWIG_fail;
19378 }
19379 }
19380 if (obj1) {
19381 {
19382 arg2 = (int)(SWIG_As_int(obj1));
19383 if (SWIG_arg_fail(2)) SWIG_fail;
19384 }
19385 }
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19389
19390 wxPyEndAllowThreads(__tstate);
19391 if (PyErr_Occurred()) SWIG_fail;
19392 }
19393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19394 return resultobj;
19395 fail:
19396 return NULL;
19397 }
19398
19399
19400 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19401 PyObject *resultobj;
19402 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19403 wxWindow *result;
19404 PyObject * obj0 = 0 ;
19405 char *kwnames[] = {
19406 (char *) "self", NULL
19407 };
19408
19409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19411 if (SWIG_arg_fail(1)) SWIG_fail;
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19415
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 {
19420 resultobj = wxPyMake_wxObject(result, 0);
19421 }
19422 return resultobj;
19423 fail:
19424 return NULL;
19425 }
19426
19427
19428 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19429 PyObject *resultobj;
19430 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19431 wxWindow *arg2 = (wxWindow *) 0 ;
19432 PyObject * obj0 = 0 ;
19433 PyObject * obj1 = 0 ;
19434 char *kwnames[] = {
19435 (char *) "self",(char *) "win", NULL
19436 };
19437
19438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19440 if (SWIG_arg_fail(1)) SWIG_fail;
19441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19442 if (SWIG_arg_fail(2)) SWIG_fail;
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 (arg1)->SetWindow(arg2);
19446
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 Py_INCREF(Py_None); resultobj = Py_None;
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19458 PyObject *obj;
19459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19460 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19461 Py_INCREF(obj);
19462 return Py_BuildValue((char *)"");
19463 }
19464 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19465 PyObject *resultobj;
19466 wxWindow *arg1 = (wxWindow *) NULL ;
19467 wxChildFocusEvent *result;
19468 PyObject * obj0 = 0 ;
19469 char *kwnames[] = {
19470 (char *) "win", NULL
19471 };
19472
19473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19474 if (obj0) {
19475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19476 if (SWIG_arg_fail(1)) SWIG_fail;
19477 }
19478 {
19479 PyThreadState* __tstate = wxPyBeginAllowThreads();
19480 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19481
19482 wxPyEndAllowThreads(__tstate);
19483 if (PyErr_Occurred()) SWIG_fail;
19484 }
19485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19493 PyObject *resultobj;
19494 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19495 wxWindow *result;
19496 PyObject * obj0 = 0 ;
19497 char *kwnames[] = {
19498 (char *) "self", NULL
19499 };
19500
19501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19503 if (SWIG_arg_fail(1)) SWIG_fail;
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19507
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 {
19512 resultobj = wxPyMake_wxObject(result, 0);
19513 }
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19521 PyObject *obj;
19522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19523 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19524 Py_INCREF(obj);
19525 return Py_BuildValue((char *)"");
19526 }
19527 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj;
19529 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19530 bool arg2 = (bool) true ;
19531 int arg3 = (int) 0 ;
19532 wxActivateEvent *result;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 PyObject * obj2 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "type",(char *) "active",(char *) "Id", NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19541 if (obj0) {
19542 {
19543 arg1 = (wxEventType)(SWIG_As_int(obj0));
19544 if (SWIG_arg_fail(1)) SWIG_fail;
19545 }
19546 }
19547 if (obj1) {
19548 {
19549 arg2 = (bool)(SWIG_As_bool(obj1));
19550 if (SWIG_arg_fail(2)) SWIG_fail;
19551 }
19552 }
19553 if (obj2) {
19554 {
19555 arg3 = (int)(SWIG_As_int(obj2));
19556 if (SWIG_arg_fail(3)) SWIG_fail;
19557 }
19558 }
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19562
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19567 return resultobj;
19568 fail:
19569 return NULL;
19570 }
19571
19572
19573 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19574 PyObject *resultobj;
19575 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19576 bool result;
19577 PyObject * obj0 = 0 ;
19578 char *kwnames[] = {
19579 (char *) "self", NULL
19580 };
19581
19582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 {
19593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19594 }
19595 return resultobj;
19596 fail:
19597 return NULL;
19598 }
19599
19600
19601 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19602 PyObject *obj;
19603 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19604 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19605 Py_INCREF(obj);
19606 return Py_BuildValue((char *)"");
19607 }
19608 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19609 PyObject *resultobj;
19610 int arg1 = (int) 0 ;
19611 wxInitDialogEvent *result;
19612 PyObject * obj0 = 0 ;
19613 char *kwnames[] = {
19614 (char *) "Id", NULL
19615 };
19616
19617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19618 if (obj0) {
19619 {
19620 arg1 = (int)(SWIG_As_int(obj0));
19621 if (SWIG_arg_fail(1)) SWIG_fail;
19622 }
19623 }
19624 {
19625 PyThreadState* __tstate = wxPyBeginAllowThreads();
19626 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19627
19628 wxPyEndAllowThreads(__tstate);
19629 if (PyErr_Occurred()) SWIG_fail;
19630 }
19631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19632 return resultobj;
19633 fail:
19634 return NULL;
19635 }
19636
19637
19638 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19639 PyObject *obj;
19640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19641 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19642 Py_INCREF(obj);
19643 return Py_BuildValue((char *)"");
19644 }
19645 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19646 PyObject *resultobj;
19647 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19648 int arg2 = (int) 0 ;
19649 wxMenu *arg3 = (wxMenu *) NULL ;
19650 wxMenuEvent *result;
19651 PyObject * obj0 = 0 ;
19652 PyObject * obj1 = 0 ;
19653 PyObject * obj2 = 0 ;
19654 char *kwnames[] = {
19655 (char *) "type",(char *) "winid",(char *) "menu", NULL
19656 };
19657
19658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19659 if (obj0) {
19660 {
19661 arg1 = (wxEventType)(SWIG_As_int(obj0));
19662 if (SWIG_arg_fail(1)) SWIG_fail;
19663 }
19664 }
19665 if (obj1) {
19666 {
19667 arg2 = (int)(SWIG_As_int(obj1));
19668 if (SWIG_arg_fail(2)) SWIG_fail;
19669 }
19670 }
19671 if (obj2) {
19672 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19673 if (SWIG_arg_fail(3)) SWIG_fail;
19674 }
19675 {
19676 PyThreadState* __tstate = wxPyBeginAllowThreads();
19677 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19678
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19690 PyObject *resultobj;
19691 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19692 int result;
19693 PyObject * obj0 = 0 ;
19694 char *kwnames[] = {
19695 (char *) "self", NULL
19696 };
19697
19698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19700 if (SWIG_arg_fail(1)) SWIG_fail;
19701 {
19702 PyThreadState* __tstate = wxPyBeginAllowThreads();
19703 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19704
19705 wxPyEndAllowThreads(__tstate);
19706 if (PyErr_Occurred()) SWIG_fail;
19707 }
19708 {
19709 resultobj = SWIG_From_int((int)(result));
19710 }
19711 return resultobj;
19712 fail:
19713 return NULL;
19714 }
19715
19716
19717 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19718 PyObject *resultobj;
19719 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19720 bool result;
19721 PyObject * obj0 = 0 ;
19722 char *kwnames[] = {
19723 (char *) "self", NULL
19724 };
19725
19726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19728 if (SWIG_arg_fail(1)) SWIG_fail;
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19732
19733 wxPyEndAllowThreads(__tstate);
19734 if (PyErr_Occurred()) SWIG_fail;
19735 }
19736 {
19737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19738 }
19739 return resultobj;
19740 fail:
19741 return NULL;
19742 }
19743
19744
19745 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19746 PyObject *resultobj;
19747 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19748 wxMenu *result;
19749 PyObject * obj0 = 0 ;
19750 char *kwnames[] = {
19751 (char *) "self", NULL
19752 };
19753
19754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19756 if (SWIG_arg_fail(1)) SWIG_fail;
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19760
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 {
19765 resultobj = wxPyMake_wxObject(result, 0);
19766 }
19767 return resultobj;
19768 fail:
19769 return NULL;
19770 }
19771
19772
19773 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19774 PyObject *obj;
19775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19776 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19777 Py_INCREF(obj);
19778 return Py_BuildValue((char *)"");
19779 }
19780 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19781 PyObject *resultobj;
19782 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19783 int arg2 = (int) 0 ;
19784 wxCloseEvent *result;
19785 PyObject * obj0 = 0 ;
19786 PyObject * obj1 = 0 ;
19787 char *kwnames[] = {
19788 (char *) "type",(char *) "winid", NULL
19789 };
19790
19791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19792 if (obj0) {
19793 {
19794 arg1 = (wxEventType)(SWIG_As_int(obj0));
19795 if (SWIG_arg_fail(1)) SWIG_fail;
19796 }
19797 }
19798 if (obj1) {
19799 {
19800 arg2 = (int)(SWIG_As_int(obj1));
19801 if (SWIG_arg_fail(2)) SWIG_fail;
19802 }
19803 }
19804 {
19805 PyThreadState* __tstate = wxPyBeginAllowThreads();
19806 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19807
19808 wxPyEndAllowThreads(__tstate);
19809 if (PyErr_Occurred()) SWIG_fail;
19810 }
19811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19812 return resultobj;
19813 fail:
19814 return NULL;
19815 }
19816
19817
19818 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19819 PyObject *resultobj;
19820 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19821 bool arg2 ;
19822 PyObject * obj0 = 0 ;
19823 PyObject * obj1 = 0 ;
19824 char *kwnames[] = {
19825 (char *) "self",(char *) "logOff", NULL
19826 };
19827
19828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19830 if (SWIG_arg_fail(1)) SWIG_fail;
19831 {
19832 arg2 = (bool)(SWIG_As_bool(obj1));
19833 if (SWIG_arg_fail(2)) SWIG_fail;
19834 }
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 (arg1)->SetLoggingOff(arg2);
19838
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 Py_INCREF(Py_None); resultobj = Py_None;
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj;
19851 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19852 bool result;
19853 PyObject * obj0 = 0 ;
19854 char *kwnames[] = {
19855 (char *) "self", NULL
19856 };
19857
19858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19860 if (SWIG_arg_fail(1)) SWIG_fail;
19861 {
19862 PyThreadState* __tstate = wxPyBeginAllowThreads();
19863 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19864
19865 wxPyEndAllowThreads(__tstate);
19866 if (PyErr_Occurred()) SWIG_fail;
19867 }
19868 {
19869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19870 }
19871 return resultobj;
19872 fail:
19873 return NULL;
19874 }
19875
19876
19877 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19878 PyObject *resultobj;
19879 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19880 bool arg2 = (bool) true ;
19881 PyObject * obj0 = 0 ;
19882 PyObject * obj1 = 0 ;
19883 char *kwnames[] = {
19884 (char *) "self",(char *) "veto", NULL
19885 };
19886
19887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19889 if (SWIG_arg_fail(1)) SWIG_fail;
19890 if (obj1) {
19891 {
19892 arg2 = (bool)(SWIG_As_bool(obj1));
19893 if (SWIG_arg_fail(2)) SWIG_fail;
19894 }
19895 }
19896 {
19897 PyThreadState* __tstate = wxPyBeginAllowThreads();
19898 (arg1)->Veto(arg2);
19899
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 Py_INCREF(Py_None); resultobj = Py_None;
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19911 PyObject *resultobj;
19912 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19913 bool arg2 ;
19914 PyObject * obj0 = 0 ;
19915 PyObject * obj1 = 0 ;
19916 char *kwnames[] = {
19917 (char *) "self",(char *) "canVeto", NULL
19918 };
19919
19920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19922 if (SWIG_arg_fail(1)) SWIG_fail;
19923 {
19924 arg2 = (bool)(SWIG_As_bool(obj1));
19925 if (SWIG_arg_fail(2)) SWIG_fail;
19926 }
19927 {
19928 PyThreadState* __tstate = wxPyBeginAllowThreads();
19929 (arg1)->SetCanVeto(arg2);
19930
19931 wxPyEndAllowThreads(__tstate);
19932 if (PyErr_Occurred()) SWIG_fail;
19933 }
19934 Py_INCREF(Py_None); resultobj = Py_None;
19935 return resultobj;
19936 fail:
19937 return NULL;
19938 }
19939
19940
19941 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19942 PyObject *resultobj;
19943 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19944 bool result;
19945 PyObject * obj0 = 0 ;
19946 char *kwnames[] = {
19947 (char *) "self", NULL
19948 };
19949
19950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19952 if (SWIG_arg_fail(1)) SWIG_fail;
19953 {
19954 PyThreadState* __tstate = wxPyBeginAllowThreads();
19955 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19956
19957 wxPyEndAllowThreads(__tstate);
19958 if (PyErr_Occurred()) SWIG_fail;
19959 }
19960 {
19961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19962 }
19963 return resultobj;
19964 fail:
19965 return NULL;
19966 }
19967
19968
19969 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19970 PyObject *resultobj;
19971 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19972 bool result;
19973 PyObject * obj0 = 0 ;
19974 char *kwnames[] = {
19975 (char *) "self", NULL
19976 };
19977
19978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19980 if (SWIG_arg_fail(1)) SWIG_fail;
19981 {
19982 PyThreadState* __tstate = wxPyBeginAllowThreads();
19983 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19984
19985 wxPyEndAllowThreads(__tstate);
19986 if (PyErr_Occurred()) SWIG_fail;
19987 }
19988 {
19989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19990 }
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19998 PyObject *obj;
19999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20000 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20001 Py_INCREF(obj);
20002 return Py_BuildValue((char *)"");
20003 }
20004 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20005 PyObject *resultobj;
20006 int arg1 = (int) 0 ;
20007 bool arg2 = (bool) false ;
20008 wxShowEvent *result;
20009 PyObject * obj0 = 0 ;
20010 PyObject * obj1 = 0 ;
20011 char *kwnames[] = {
20012 (char *) "winid",(char *) "show", NULL
20013 };
20014
20015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20016 if (obj0) {
20017 {
20018 arg1 = (int)(SWIG_As_int(obj0));
20019 if (SWIG_arg_fail(1)) SWIG_fail;
20020 }
20021 }
20022 if (obj1) {
20023 {
20024 arg2 = (bool)(SWIG_As_bool(obj1));
20025 if (SWIG_arg_fail(2)) SWIG_fail;
20026 }
20027 }
20028 {
20029 PyThreadState* __tstate = wxPyBeginAllowThreads();
20030 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20031
20032 wxPyEndAllowThreads(__tstate);
20033 if (PyErr_Occurred()) SWIG_fail;
20034 }
20035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20043 PyObject *resultobj;
20044 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20045 bool arg2 ;
20046 PyObject * obj0 = 0 ;
20047 PyObject * obj1 = 0 ;
20048 char *kwnames[] = {
20049 (char *) "self",(char *) "show", NULL
20050 };
20051
20052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20054 if (SWIG_arg_fail(1)) SWIG_fail;
20055 {
20056 arg2 = (bool)(SWIG_As_bool(obj1));
20057 if (SWIG_arg_fail(2)) SWIG_fail;
20058 }
20059 {
20060 PyThreadState* __tstate = wxPyBeginAllowThreads();
20061 (arg1)->SetShow(arg2);
20062
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 Py_INCREF(Py_None); resultobj = Py_None;
20067 return resultobj;
20068 fail:
20069 return NULL;
20070 }
20071
20072
20073 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20074 PyObject *resultobj;
20075 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20076 bool result;
20077 PyObject * obj0 = 0 ;
20078 char *kwnames[] = {
20079 (char *) "self", NULL
20080 };
20081
20082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20084 if (SWIG_arg_fail(1)) SWIG_fail;
20085 {
20086 PyThreadState* __tstate = wxPyBeginAllowThreads();
20087 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20088
20089 wxPyEndAllowThreads(__tstate);
20090 if (PyErr_Occurred()) SWIG_fail;
20091 }
20092 {
20093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20094 }
20095 return resultobj;
20096 fail:
20097 return NULL;
20098 }
20099
20100
20101 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20102 PyObject *obj;
20103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20104 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20105 Py_INCREF(obj);
20106 return Py_BuildValue((char *)"");
20107 }
20108 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20109 PyObject *resultobj;
20110 int arg1 = (int) 0 ;
20111 bool arg2 = (bool) true ;
20112 wxIconizeEvent *result;
20113 PyObject * obj0 = 0 ;
20114 PyObject * obj1 = 0 ;
20115 char *kwnames[] = {
20116 (char *) "id",(char *) "iconized", NULL
20117 };
20118
20119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20120 if (obj0) {
20121 {
20122 arg1 = (int)(SWIG_As_int(obj0));
20123 if (SWIG_arg_fail(1)) SWIG_fail;
20124 }
20125 }
20126 if (obj1) {
20127 {
20128 arg2 = (bool)(SWIG_As_bool(obj1));
20129 if (SWIG_arg_fail(2)) SWIG_fail;
20130 }
20131 }
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20135
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20147 PyObject *resultobj;
20148 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20149 bool result;
20150 PyObject * obj0 = 0 ;
20151 char *kwnames[] = {
20152 (char *) "self", NULL
20153 };
20154
20155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20157 if (SWIG_arg_fail(1)) SWIG_fail;
20158 {
20159 PyThreadState* __tstate = wxPyBeginAllowThreads();
20160 result = (bool)(arg1)->Iconized();
20161
20162 wxPyEndAllowThreads(__tstate);
20163 if (PyErr_Occurred()) SWIG_fail;
20164 }
20165 {
20166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20167 }
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20175 PyObject *obj;
20176 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20177 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20178 Py_INCREF(obj);
20179 return Py_BuildValue((char *)"");
20180 }
20181 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20182 PyObject *resultobj;
20183 int arg1 = (int) 0 ;
20184 wxMaximizeEvent *result;
20185 PyObject * obj0 = 0 ;
20186 char *kwnames[] = {
20187 (char *) "id", NULL
20188 };
20189
20190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20191 if (obj0) {
20192 {
20193 arg1 = (int)(SWIG_As_int(obj0));
20194 if (SWIG_arg_fail(1)) SWIG_fail;
20195 }
20196 }
20197 {
20198 PyThreadState* __tstate = wxPyBeginAllowThreads();
20199 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20200
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20212 PyObject *obj;
20213 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20214 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20215 Py_INCREF(obj);
20216 return Py_BuildValue((char *)"");
20217 }
20218 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20219 PyObject *resultobj;
20220 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20221 wxPoint result;
20222 PyObject * obj0 = 0 ;
20223 char *kwnames[] = {
20224 (char *) "self", NULL
20225 };
20226
20227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20229 if (SWIG_arg_fail(1)) SWIG_fail;
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 result = (arg1)->GetPosition();
20233
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 {
20238 wxPoint * resultptr;
20239 resultptr = new wxPoint((wxPoint &)(result));
20240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20241 }
20242 return resultobj;
20243 fail:
20244 return NULL;
20245 }
20246
20247
20248 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20249 PyObject *resultobj;
20250 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20251 int result;
20252 PyObject * obj0 = 0 ;
20253 char *kwnames[] = {
20254 (char *) "self", NULL
20255 };
20256
20257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20259 if (SWIG_arg_fail(1)) SWIG_fail;
20260 {
20261 PyThreadState* __tstate = wxPyBeginAllowThreads();
20262 result = (int)(arg1)->GetNumberOfFiles();
20263
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 {
20268 resultobj = SWIG_From_int((int)(result));
20269 }
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20277 PyObject *resultobj;
20278 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20279 PyObject *result;
20280 PyObject * obj0 = 0 ;
20281 char *kwnames[] = {
20282 (char *) "self", NULL
20283 };
20284
20285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20287 if (SWIG_arg_fail(1)) SWIG_fail;
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20291
20292 wxPyEndAllowThreads(__tstate);
20293 if (PyErr_Occurred()) SWIG_fail;
20294 }
20295 resultobj = result;
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20303 PyObject *obj;
20304 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20305 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20306 Py_INCREF(obj);
20307 return Py_BuildValue((char *)"");
20308 }
20309 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj;
20311 int arg1 = (int) 0 ;
20312 wxUpdateUIEvent *result;
20313 PyObject * obj0 = 0 ;
20314 char *kwnames[] = {
20315 (char *) "commandId", NULL
20316 };
20317
20318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20319 if (obj0) {
20320 {
20321 arg1 = (int)(SWIG_As_int(obj0));
20322 if (SWIG_arg_fail(1)) SWIG_fail;
20323 }
20324 }
20325 {
20326 PyThreadState* __tstate = wxPyBeginAllowThreads();
20327 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20328
20329 wxPyEndAllowThreads(__tstate);
20330 if (PyErr_Occurred()) SWIG_fail;
20331 }
20332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj;
20341 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20342 bool result;
20343 PyObject * obj0 = 0 ;
20344 char *kwnames[] = {
20345 (char *) "self", NULL
20346 };
20347
20348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20350 if (SWIG_arg_fail(1)) SWIG_fail;
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20360 }
20361 return resultobj;
20362 fail:
20363 return NULL;
20364 }
20365
20366
20367 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20368 PyObject *resultobj;
20369 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20370 bool result;
20371 PyObject * obj0 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20378 if (SWIG_arg_fail(1)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20382
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 {
20387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20388 }
20389 return resultobj;
20390 fail:
20391 return NULL;
20392 }
20393
20394
20395 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20396 PyObject *resultobj;
20397 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20398 wxString result;
20399 PyObject * obj0 = 0 ;
20400 char *kwnames[] = {
20401 (char *) "self", NULL
20402 };
20403
20404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20406 if (SWIG_arg_fail(1)) SWIG_fail;
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20410
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 {
20415 #if wxUSE_UNICODE
20416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20417 #else
20418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20419 #endif
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj;
20429 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20430 bool result;
20431 PyObject * obj0 = 0 ;
20432 char *kwnames[] = {
20433 (char *) "self", NULL
20434 };
20435
20436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20438 if (SWIG_arg_fail(1)) SWIG_fail;
20439 {
20440 PyThreadState* __tstate = wxPyBeginAllowThreads();
20441 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20442
20443 wxPyEndAllowThreads(__tstate);
20444 if (PyErr_Occurred()) SWIG_fail;
20445 }
20446 {
20447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20448 }
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj;
20457 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20458 bool result;
20459 PyObject * obj0 = 0 ;
20460 char *kwnames[] = {
20461 (char *) "self", NULL
20462 };
20463
20464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20466 if (SWIG_arg_fail(1)) SWIG_fail;
20467 {
20468 PyThreadState* __tstate = wxPyBeginAllowThreads();
20469 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20470
20471 wxPyEndAllowThreads(__tstate);
20472 if (PyErr_Occurred()) SWIG_fail;
20473 }
20474 {
20475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20476 }
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20484 PyObject *resultobj;
20485 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20486 bool result;
20487 PyObject * obj0 = 0 ;
20488 char *kwnames[] = {
20489 (char *) "self", NULL
20490 };
20491
20492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20494 if (SWIG_arg_fail(1)) SWIG_fail;
20495 {
20496 PyThreadState* __tstate = wxPyBeginAllowThreads();
20497 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20498
20499 wxPyEndAllowThreads(__tstate);
20500 if (PyErr_Occurred()) SWIG_fail;
20501 }
20502 {
20503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20504 }
20505 return resultobj;
20506 fail:
20507 return NULL;
20508 }
20509
20510
20511 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20512 PyObject *resultobj;
20513 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20514 bool arg2 ;
20515 PyObject * obj0 = 0 ;
20516 PyObject * obj1 = 0 ;
20517 char *kwnames[] = {
20518 (char *) "self",(char *) "check", NULL
20519 };
20520
20521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20523 if (SWIG_arg_fail(1)) SWIG_fail;
20524 {
20525 arg2 = (bool)(SWIG_As_bool(obj1));
20526 if (SWIG_arg_fail(2)) SWIG_fail;
20527 }
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 (arg1)->Check(arg2);
20531
20532 wxPyEndAllowThreads(__tstate);
20533 if (PyErr_Occurred()) SWIG_fail;
20534 }
20535 Py_INCREF(Py_None); resultobj = Py_None;
20536 return resultobj;
20537 fail:
20538 return NULL;
20539 }
20540
20541
20542 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20543 PyObject *resultobj;
20544 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20545 bool arg2 ;
20546 PyObject * obj0 = 0 ;
20547 PyObject * obj1 = 0 ;
20548 char *kwnames[] = {
20549 (char *) "self",(char *) "enable", NULL
20550 };
20551
20552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20554 if (SWIG_arg_fail(1)) SWIG_fail;
20555 {
20556 arg2 = (bool)(SWIG_As_bool(obj1));
20557 if (SWIG_arg_fail(2)) SWIG_fail;
20558 }
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 (arg1)->Enable(arg2);
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 Py_INCREF(Py_None); resultobj = Py_None;
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj;
20575 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20576 wxString *arg2 = 0 ;
20577 bool temp2 = false ;
20578 PyObject * obj0 = 0 ;
20579 PyObject * obj1 = 0 ;
20580 char *kwnames[] = {
20581 (char *) "self",(char *) "text", NULL
20582 };
20583
20584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20586 if (SWIG_arg_fail(1)) SWIG_fail;
20587 {
20588 arg2 = wxString_in_helper(obj1);
20589 if (arg2 == NULL) SWIG_fail;
20590 temp2 = true;
20591 }
20592 {
20593 PyThreadState* __tstate = wxPyBeginAllowThreads();
20594 (arg1)->SetText((wxString const &)*arg2);
20595
20596 wxPyEndAllowThreads(__tstate);
20597 if (PyErr_Occurred()) SWIG_fail;
20598 }
20599 Py_INCREF(Py_None); resultobj = Py_None;
20600 {
20601 if (temp2)
20602 delete arg2;
20603 }
20604 return resultobj;
20605 fail:
20606 {
20607 if (temp2)
20608 delete arg2;
20609 }
20610 return NULL;
20611 }
20612
20613
20614 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20615 PyObject *resultobj;
20616 long arg1 ;
20617 PyObject * obj0 = 0 ;
20618 char *kwnames[] = {
20619 (char *) "updateInterval", NULL
20620 };
20621
20622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20623 {
20624 arg1 = (long)(SWIG_As_long(obj0));
20625 if (SWIG_arg_fail(1)) SWIG_fail;
20626 }
20627 {
20628 PyThreadState* __tstate = wxPyBeginAllowThreads();
20629 wxUpdateUIEvent::SetUpdateInterval(arg1);
20630
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 Py_INCREF(Py_None); resultobj = Py_None;
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20642 PyObject *resultobj;
20643 long result;
20644 char *kwnames[] = {
20645 NULL
20646 };
20647
20648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20649 {
20650 PyThreadState* __tstate = wxPyBeginAllowThreads();
20651 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20652
20653 wxPyEndAllowThreads(__tstate);
20654 if (PyErr_Occurred()) SWIG_fail;
20655 }
20656 {
20657 resultobj = SWIG_From_long((long)(result));
20658 }
20659 return resultobj;
20660 fail:
20661 return NULL;
20662 }
20663
20664
20665 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20666 PyObject *resultobj;
20667 wxWindow *arg1 = (wxWindow *) 0 ;
20668 bool result;
20669 PyObject * obj0 = 0 ;
20670 char *kwnames[] = {
20671 (char *) "win", NULL
20672 };
20673
20674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20676 if (SWIG_arg_fail(1)) SWIG_fail;
20677 {
20678 PyThreadState* __tstate = wxPyBeginAllowThreads();
20679 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20680
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 {
20685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20686 }
20687 return resultobj;
20688 fail:
20689 return NULL;
20690 }
20691
20692
20693 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20694 PyObject *resultobj;
20695 char *kwnames[] = {
20696 NULL
20697 };
20698
20699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 wxUpdateUIEvent::ResetUpdateTime();
20703
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 Py_INCREF(Py_None); resultobj = Py_None;
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20715 PyObject *resultobj;
20716 wxUpdateUIMode arg1 ;
20717 PyObject * obj0 = 0 ;
20718 char *kwnames[] = {
20719 (char *) "mode", NULL
20720 };
20721
20722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20723 {
20724 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20725 if (SWIG_arg_fail(1)) SWIG_fail;
20726 }
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20730
20731 wxPyEndAllowThreads(__tstate);
20732 if (PyErr_Occurred()) SWIG_fail;
20733 }
20734 Py_INCREF(Py_None); resultobj = Py_None;
20735 return resultobj;
20736 fail:
20737 return NULL;
20738 }
20739
20740
20741 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20742 PyObject *resultobj;
20743 wxUpdateUIMode result;
20744 char *kwnames[] = {
20745 NULL
20746 };
20747
20748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20749 {
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20752
20753 wxPyEndAllowThreads(__tstate);
20754 if (PyErr_Occurred()) SWIG_fail;
20755 }
20756 resultobj = SWIG_From_int((result));
20757 return resultobj;
20758 fail:
20759 return NULL;
20760 }
20761
20762
20763 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20764 PyObject *obj;
20765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20766 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20767 Py_INCREF(obj);
20768 return Py_BuildValue((char *)"");
20769 }
20770 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20771 PyObject *resultobj;
20772 wxSysColourChangedEvent *result;
20773 char *kwnames[] = {
20774 NULL
20775 };
20776
20777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20778 {
20779 PyThreadState* __tstate = wxPyBeginAllowThreads();
20780 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20781
20782 wxPyEndAllowThreads(__tstate);
20783 if (PyErr_Occurred()) SWIG_fail;
20784 }
20785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20786 return resultobj;
20787 fail:
20788 return NULL;
20789 }
20790
20791
20792 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20793 PyObject *obj;
20794 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20795 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20796 Py_INCREF(obj);
20797 return Py_BuildValue((char *)"");
20798 }
20799 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20800 PyObject *resultobj;
20801 int arg1 = (int) 0 ;
20802 wxWindow *arg2 = (wxWindow *) NULL ;
20803 wxMouseCaptureChangedEvent *result;
20804 PyObject * obj0 = 0 ;
20805 PyObject * obj1 = 0 ;
20806 char *kwnames[] = {
20807 (char *) "winid",(char *) "gainedCapture", NULL
20808 };
20809
20810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20811 if (obj0) {
20812 {
20813 arg1 = (int)(SWIG_As_int(obj0));
20814 if (SWIG_arg_fail(1)) SWIG_fail;
20815 }
20816 }
20817 if (obj1) {
20818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20819 if (SWIG_arg_fail(2)) SWIG_fail;
20820 }
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20824
20825 wxPyEndAllowThreads(__tstate);
20826 if (PyErr_Occurred()) SWIG_fail;
20827 }
20828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20829 return resultobj;
20830 fail:
20831 return NULL;
20832 }
20833
20834
20835 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20836 PyObject *resultobj;
20837 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20838 wxWindow *result;
20839 PyObject * obj0 = 0 ;
20840 char *kwnames[] = {
20841 (char *) "self", NULL
20842 };
20843
20844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20846 if (SWIG_arg_fail(1)) SWIG_fail;
20847 {
20848 PyThreadState* __tstate = wxPyBeginAllowThreads();
20849 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20850
20851 wxPyEndAllowThreads(__tstate);
20852 if (PyErr_Occurred()) SWIG_fail;
20853 }
20854 {
20855 resultobj = wxPyMake_wxObject(result, 0);
20856 }
20857 return resultobj;
20858 fail:
20859 return NULL;
20860 }
20861
20862
20863 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20864 PyObject *obj;
20865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20866 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20867 Py_INCREF(obj);
20868 return Py_BuildValue((char *)"");
20869 }
20870 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20871 PyObject *resultobj;
20872 wxDisplayChangedEvent *result;
20873 char *kwnames[] = {
20874 NULL
20875 };
20876
20877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20878 {
20879 PyThreadState* __tstate = wxPyBeginAllowThreads();
20880 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20881
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20893 PyObject *obj;
20894 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20895 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20896 Py_INCREF(obj);
20897 return Py_BuildValue((char *)"");
20898 }
20899 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20900 PyObject *resultobj;
20901 int arg1 = (int) 0 ;
20902 wxPaletteChangedEvent *result;
20903 PyObject * obj0 = 0 ;
20904 char *kwnames[] = {
20905 (char *) "id", NULL
20906 };
20907
20908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20909 if (obj0) {
20910 {
20911 arg1 = (int)(SWIG_As_int(obj0));
20912 if (SWIG_arg_fail(1)) SWIG_fail;
20913 }
20914 }
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20918
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20930 PyObject *resultobj;
20931 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20932 wxWindow *arg2 = (wxWindow *) 0 ;
20933 PyObject * obj0 = 0 ;
20934 PyObject * obj1 = 0 ;
20935 char *kwnames[] = {
20936 (char *) "self",(char *) "win", NULL
20937 };
20938
20939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20941 if (SWIG_arg_fail(1)) SWIG_fail;
20942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20943 if (SWIG_arg_fail(2)) SWIG_fail;
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 (arg1)->SetChangedWindow(arg2);
20947
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 Py_INCREF(Py_None); resultobj = Py_None;
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20959 PyObject *resultobj;
20960 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20961 wxWindow *result;
20962 PyObject * obj0 = 0 ;
20963 char *kwnames[] = {
20964 (char *) "self", NULL
20965 };
20966
20967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20969 if (SWIG_arg_fail(1)) SWIG_fail;
20970 {
20971 PyThreadState* __tstate = wxPyBeginAllowThreads();
20972 result = (wxWindow *)(arg1)->GetChangedWindow();
20973
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 {
20978 resultobj = wxPyMake_wxObject(result, 0);
20979 }
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20987 PyObject *obj;
20988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20989 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20990 Py_INCREF(obj);
20991 return Py_BuildValue((char *)"");
20992 }
20993 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20994 PyObject *resultobj;
20995 int arg1 = (int) 0 ;
20996 wxQueryNewPaletteEvent *result;
20997 PyObject * obj0 = 0 ;
20998 char *kwnames[] = {
20999 (char *) "winid", NULL
21000 };
21001
21002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21003 if (obj0) {
21004 {
21005 arg1 = (int)(SWIG_As_int(obj0));
21006 if (SWIG_arg_fail(1)) SWIG_fail;
21007 }
21008 }
21009 {
21010 PyThreadState* __tstate = wxPyBeginAllowThreads();
21011 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21012
21013 wxPyEndAllowThreads(__tstate);
21014 if (PyErr_Occurred()) SWIG_fail;
21015 }
21016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21017 return resultobj;
21018 fail:
21019 return NULL;
21020 }
21021
21022
21023 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21024 PyObject *resultobj;
21025 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21026 bool arg2 ;
21027 PyObject * obj0 = 0 ;
21028 PyObject * obj1 = 0 ;
21029 char *kwnames[] = {
21030 (char *) "self",(char *) "realized", NULL
21031 };
21032
21033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21035 if (SWIG_arg_fail(1)) SWIG_fail;
21036 {
21037 arg2 = (bool)(SWIG_As_bool(obj1));
21038 if (SWIG_arg_fail(2)) SWIG_fail;
21039 }
21040 {
21041 PyThreadState* __tstate = wxPyBeginAllowThreads();
21042 (arg1)->SetPaletteRealized(arg2);
21043
21044 wxPyEndAllowThreads(__tstate);
21045 if (PyErr_Occurred()) SWIG_fail;
21046 }
21047 Py_INCREF(Py_None); resultobj = Py_None;
21048 return resultobj;
21049 fail:
21050 return NULL;
21051 }
21052
21053
21054 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21055 PyObject *resultobj;
21056 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21057 bool result;
21058 PyObject * obj0 = 0 ;
21059 char *kwnames[] = {
21060 (char *) "self", NULL
21061 };
21062
21063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21065 if (SWIG_arg_fail(1)) SWIG_fail;
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21069
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 {
21074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21075 }
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21083 PyObject *obj;
21084 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21085 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21086 Py_INCREF(obj);
21087 return Py_BuildValue((char *)"");
21088 }
21089 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21090 PyObject *resultobj;
21091 wxNavigationKeyEvent *result;
21092 char *kwnames[] = {
21093 NULL
21094 };
21095
21096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj;
21113 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21114 bool result;
21115 PyObject * obj0 = 0 ;
21116 char *kwnames[] = {
21117 (char *) "self", NULL
21118 };
21119
21120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21122 if (SWIG_arg_fail(1)) SWIG_fail;
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21126
21127 wxPyEndAllowThreads(__tstate);
21128 if (PyErr_Occurred()) SWIG_fail;
21129 }
21130 {
21131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21132 }
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21140 PyObject *resultobj;
21141 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21142 bool arg2 ;
21143 PyObject * obj0 = 0 ;
21144 PyObject * obj1 = 0 ;
21145 char *kwnames[] = {
21146 (char *) "self",(char *) "forward", NULL
21147 };
21148
21149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21151 if (SWIG_arg_fail(1)) SWIG_fail;
21152 {
21153 arg2 = (bool)(SWIG_As_bool(obj1));
21154 if (SWIG_arg_fail(2)) SWIG_fail;
21155 }
21156 {
21157 PyThreadState* __tstate = wxPyBeginAllowThreads();
21158 (arg1)->SetDirection(arg2);
21159
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 Py_INCREF(Py_None); resultobj = Py_None;
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21173 bool result;
21174 PyObject * obj0 = 0 ;
21175 char *kwnames[] = {
21176 (char *) "self", NULL
21177 };
21178
21179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21181 if (SWIG_arg_fail(1)) SWIG_fail;
21182 {
21183 PyThreadState* __tstate = wxPyBeginAllowThreads();
21184 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21185
21186 wxPyEndAllowThreads(__tstate);
21187 if (PyErr_Occurred()) SWIG_fail;
21188 }
21189 {
21190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21191 }
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21199 PyObject *resultobj;
21200 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21201 bool arg2 ;
21202 PyObject * obj0 = 0 ;
21203 PyObject * obj1 = 0 ;
21204 char *kwnames[] = {
21205 (char *) "self",(char *) "ischange", NULL
21206 };
21207
21208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21210 if (SWIG_arg_fail(1)) SWIG_fail;
21211 {
21212 arg2 = (bool)(SWIG_As_bool(obj1));
21213 if (SWIG_arg_fail(2)) SWIG_fail;
21214 }
21215 {
21216 PyThreadState* __tstate = wxPyBeginAllowThreads();
21217 (arg1)->SetWindowChange(arg2);
21218
21219 wxPyEndAllowThreads(__tstate);
21220 if (PyErr_Occurred()) SWIG_fail;
21221 }
21222 Py_INCREF(Py_None); resultobj = Py_None;
21223 return resultobj;
21224 fail:
21225 return NULL;
21226 }
21227
21228
21229 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21230 PyObject *resultobj;
21231 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21232 bool result;
21233 PyObject * obj0 = 0 ;
21234 char *kwnames[] = {
21235 (char *) "self", NULL
21236 };
21237
21238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21240 if (SWIG_arg_fail(1)) SWIG_fail;
21241 {
21242 PyThreadState* __tstate = wxPyBeginAllowThreads();
21243 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21244
21245 wxPyEndAllowThreads(__tstate);
21246 if (PyErr_Occurred()) SWIG_fail;
21247 }
21248 {
21249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21250 }
21251 return resultobj;
21252 fail:
21253 return NULL;
21254 }
21255
21256
21257 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21258 PyObject *resultobj;
21259 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21260 bool arg2 ;
21261 PyObject * obj0 = 0 ;
21262 PyObject * obj1 = 0 ;
21263 char *kwnames[] = {
21264 (char *) "self",(char *) "bIs", NULL
21265 };
21266
21267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21269 if (SWIG_arg_fail(1)) SWIG_fail;
21270 {
21271 arg2 = (bool)(SWIG_As_bool(obj1));
21272 if (SWIG_arg_fail(2)) SWIG_fail;
21273 }
21274 {
21275 PyThreadState* __tstate = wxPyBeginAllowThreads();
21276 (arg1)->SetFromTab(arg2);
21277
21278 wxPyEndAllowThreads(__tstate);
21279 if (PyErr_Occurred()) SWIG_fail;
21280 }
21281 Py_INCREF(Py_None); resultobj = Py_None;
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21289 PyObject *resultobj;
21290 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21291 long arg2 ;
21292 PyObject * obj0 = 0 ;
21293 PyObject * obj1 = 0 ;
21294 char *kwnames[] = {
21295 (char *) "self",(char *) "flags", NULL
21296 };
21297
21298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21300 if (SWIG_arg_fail(1)) SWIG_fail;
21301 {
21302 arg2 = (long)(SWIG_As_long(obj1));
21303 if (SWIG_arg_fail(2)) SWIG_fail;
21304 }
21305 {
21306 PyThreadState* __tstate = wxPyBeginAllowThreads();
21307 (arg1)->SetFlags(arg2);
21308
21309 wxPyEndAllowThreads(__tstate);
21310 if (PyErr_Occurred()) SWIG_fail;
21311 }
21312 Py_INCREF(Py_None); resultobj = Py_None;
21313 return resultobj;
21314 fail:
21315 return NULL;
21316 }
21317
21318
21319 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21320 PyObject *resultobj;
21321 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21322 wxWindow *result;
21323 PyObject * obj0 = 0 ;
21324 char *kwnames[] = {
21325 (char *) "self", NULL
21326 };
21327
21328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21330 if (SWIG_arg_fail(1)) SWIG_fail;
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21334
21335 wxPyEndAllowThreads(__tstate);
21336 if (PyErr_Occurred()) SWIG_fail;
21337 }
21338 {
21339 resultobj = wxPyMake_wxObject(result, 0);
21340 }
21341 return resultobj;
21342 fail:
21343 return NULL;
21344 }
21345
21346
21347 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21348 PyObject *resultobj;
21349 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21350 wxWindow *arg2 = (wxWindow *) 0 ;
21351 PyObject * obj0 = 0 ;
21352 PyObject * obj1 = 0 ;
21353 char *kwnames[] = {
21354 (char *) "self",(char *) "win", NULL
21355 };
21356
21357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21359 if (SWIG_arg_fail(1)) SWIG_fail;
21360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21361 if (SWIG_arg_fail(2)) SWIG_fail;
21362 {
21363 PyThreadState* __tstate = wxPyBeginAllowThreads();
21364 (arg1)->SetCurrentFocus(arg2);
21365
21366 wxPyEndAllowThreads(__tstate);
21367 if (PyErr_Occurred()) SWIG_fail;
21368 }
21369 Py_INCREF(Py_None); resultobj = Py_None;
21370 return resultobj;
21371 fail:
21372 return NULL;
21373 }
21374
21375
21376 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21377 PyObject *obj;
21378 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21379 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21380 Py_INCREF(obj);
21381 return Py_BuildValue((char *)"");
21382 }
21383 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21384 PyObject *resultobj;
21385 wxWindow *arg1 = (wxWindow *) NULL ;
21386 wxWindowCreateEvent *result;
21387 PyObject * obj0 = 0 ;
21388 char *kwnames[] = {
21389 (char *) "win", NULL
21390 };
21391
21392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21393 if (obj0) {
21394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21395 if (SWIG_arg_fail(1)) SWIG_fail;
21396 }
21397 {
21398 PyThreadState* __tstate = wxPyBeginAllowThreads();
21399 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21400
21401 wxPyEndAllowThreads(__tstate);
21402 if (PyErr_Occurred()) SWIG_fail;
21403 }
21404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj;
21413 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21414 wxWindow *result;
21415 PyObject * obj0 = 0 ;
21416 char *kwnames[] = {
21417 (char *) "self", NULL
21418 };
21419
21420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21422 if (SWIG_arg_fail(1)) SWIG_fail;
21423 {
21424 PyThreadState* __tstate = wxPyBeginAllowThreads();
21425 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21426
21427 wxPyEndAllowThreads(__tstate);
21428 if (PyErr_Occurred()) SWIG_fail;
21429 }
21430 {
21431 resultobj = wxPyMake_wxObject(result, 0);
21432 }
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21440 PyObject *obj;
21441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21442 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21443 Py_INCREF(obj);
21444 return Py_BuildValue((char *)"");
21445 }
21446 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21447 PyObject *resultobj;
21448 wxWindow *arg1 = (wxWindow *) NULL ;
21449 wxWindowDestroyEvent *result;
21450 PyObject * obj0 = 0 ;
21451 char *kwnames[] = {
21452 (char *) "win", NULL
21453 };
21454
21455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21456 if (obj0) {
21457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21458 if (SWIG_arg_fail(1)) SWIG_fail;
21459 }
21460 {
21461 PyThreadState* __tstate = wxPyBeginAllowThreads();
21462 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21463
21464 wxPyEndAllowThreads(__tstate);
21465 if (PyErr_Occurred()) SWIG_fail;
21466 }
21467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21468 return resultobj;
21469 fail:
21470 return NULL;
21471 }
21472
21473
21474 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21475 PyObject *resultobj;
21476 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21477 wxWindow *result;
21478 PyObject * obj0 = 0 ;
21479 char *kwnames[] = {
21480 (char *) "self", NULL
21481 };
21482
21483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21485 if (SWIG_arg_fail(1)) SWIG_fail;
21486 {
21487 PyThreadState* __tstate = wxPyBeginAllowThreads();
21488 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21489
21490 wxPyEndAllowThreads(__tstate);
21491 if (PyErr_Occurred()) SWIG_fail;
21492 }
21493 {
21494 resultobj = wxPyMake_wxObject(result, 0);
21495 }
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21503 PyObject *obj;
21504 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21505 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21506 Py_INCREF(obj);
21507 return Py_BuildValue((char *)"");
21508 }
21509 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21510 PyObject *resultobj;
21511 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21512 int arg2 = (int) 0 ;
21513 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21514 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21515 wxContextMenuEvent *result;
21516 wxPoint temp3 ;
21517 PyObject * obj0 = 0 ;
21518 PyObject * obj1 = 0 ;
21519 PyObject * obj2 = 0 ;
21520 char *kwnames[] = {
21521 (char *) "type",(char *) "winid",(char *) "pt", NULL
21522 };
21523
21524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21525 if (obj0) {
21526 {
21527 arg1 = (wxEventType)(SWIG_As_int(obj0));
21528 if (SWIG_arg_fail(1)) SWIG_fail;
21529 }
21530 }
21531 if (obj1) {
21532 {
21533 arg2 = (int)(SWIG_As_int(obj1));
21534 if (SWIG_arg_fail(2)) SWIG_fail;
21535 }
21536 }
21537 if (obj2) {
21538 {
21539 arg3 = &temp3;
21540 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21541 }
21542 }
21543 {
21544 PyThreadState* __tstate = wxPyBeginAllowThreads();
21545 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21546
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21558 PyObject *resultobj;
21559 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21560 wxPoint *result;
21561 PyObject * obj0 = 0 ;
21562 char *kwnames[] = {
21563 (char *) "self", NULL
21564 };
21565
21566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21568 if (SWIG_arg_fail(1)) SWIG_fail;
21569 {
21570 PyThreadState* __tstate = wxPyBeginAllowThreads();
21571 {
21572 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21573 result = (wxPoint *) &_result_ref;
21574 }
21575
21576 wxPyEndAllowThreads(__tstate);
21577 if (PyErr_Occurred()) SWIG_fail;
21578 }
21579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21580 return resultobj;
21581 fail:
21582 return NULL;
21583 }
21584
21585
21586 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21587 PyObject *resultobj;
21588 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21589 wxPoint *arg2 = 0 ;
21590 wxPoint temp2 ;
21591 PyObject * obj0 = 0 ;
21592 PyObject * obj1 = 0 ;
21593 char *kwnames[] = {
21594 (char *) "self",(char *) "pos", NULL
21595 };
21596
21597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21599 if (SWIG_arg_fail(1)) SWIG_fail;
21600 {
21601 arg2 = &temp2;
21602 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21603 }
21604 {
21605 PyThreadState* __tstate = wxPyBeginAllowThreads();
21606 (arg1)->SetPosition((wxPoint const &)*arg2);
21607
21608 wxPyEndAllowThreads(__tstate);
21609 if (PyErr_Occurred()) SWIG_fail;
21610 }
21611 Py_INCREF(Py_None); resultobj = Py_None;
21612 return resultobj;
21613 fail:
21614 return NULL;
21615 }
21616
21617
21618 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21619 PyObject *obj;
21620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21621 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21622 Py_INCREF(obj);
21623 return Py_BuildValue((char *)"");
21624 }
21625 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21626 PyObject *resultobj;
21627 wxIdleEvent *result;
21628 char *kwnames[] = {
21629 NULL
21630 };
21631
21632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21633 {
21634 PyThreadState* __tstate = wxPyBeginAllowThreads();
21635 result = (wxIdleEvent *)new wxIdleEvent();
21636
21637 wxPyEndAllowThreads(__tstate);
21638 if (PyErr_Occurred()) SWIG_fail;
21639 }
21640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21641 return resultobj;
21642 fail:
21643 return NULL;
21644 }
21645
21646
21647 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21648 PyObject *resultobj;
21649 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21650 bool arg2 = (bool) true ;
21651 PyObject * obj0 = 0 ;
21652 PyObject * obj1 = 0 ;
21653 char *kwnames[] = {
21654 (char *) "self",(char *) "needMore", NULL
21655 };
21656
21657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21659 if (SWIG_arg_fail(1)) SWIG_fail;
21660 if (obj1) {
21661 {
21662 arg2 = (bool)(SWIG_As_bool(obj1));
21663 if (SWIG_arg_fail(2)) SWIG_fail;
21664 }
21665 }
21666 {
21667 PyThreadState* __tstate = wxPyBeginAllowThreads();
21668 (arg1)->RequestMore(arg2);
21669
21670 wxPyEndAllowThreads(__tstate);
21671 if (PyErr_Occurred()) SWIG_fail;
21672 }
21673 Py_INCREF(Py_None); resultobj = Py_None;
21674 return resultobj;
21675 fail:
21676 return NULL;
21677 }
21678
21679
21680 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21681 PyObject *resultobj;
21682 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21683 bool result;
21684 PyObject * obj0 = 0 ;
21685 char *kwnames[] = {
21686 (char *) "self", NULL
21687 };
21688
21689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21691 if (SWIG_arg_fail(1)) SWIG_fail;
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21695
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 {
21700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21701 }
21702 return resultobj;
21703 fail:
21704 return NULL;
21705 }
21706
21707
21708 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj;
21710 wxIdleMode arg1 ;
21711 PyObject * obj0 = 0 ;
21712 char *kwnames[] = {
21713 (char *) "mode", NULL
21714 };
21715
21716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21717 {
21718 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21719 if (SWIG_arg_fail(1)) SWIG_fail;
21720 }
21721 {
21722 PyThreadState* __tstate = wxPyBeginAllowThreads();
21723 wxIdleEvent::SetMode((wxIdleMode )arg1);
21724
21725 wxPyEndAllowThreads(__tstate);
21726 if (PyErr_Occurred()) SWIG_fail;
21727 }
21728 Py_INCREF(Py_None); resultobj = Py_None;
21729 return resultobj;
21730 fail:
21731 return NULL;
21732 }
21733
21734
21735 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21736 PyObject *resultobj;
21737 wxIdleMode result;
21738 char *kwnames[] = {
21739 NULL
21740 };
21741
21742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21743 {
21744 PyThreadState* __tstate = wxPyBeginAllowThreads();
21745 result = (wxIdleMode)wxIdleEvent::GetMode();
21746
21747 wxPyEndAllowThreads(__tstate);
21748 if (PyErr_Occurred()) SWIG_fail;
21749 }
21750 resultobj = SWIG_From_int((result));
21751 return resultobj;
21752 fail:
21753 return NULL;
21754 }
21755
21756
21757 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21758 PyObject *resultobj;
21759 wxWindow *arg1 = (wxWindow *) 0 ;
21760 bool result;
21761 PyObject * obj0 = 0 ;
21762 char *kwnames[] = {
21763 (char *) "win", NULL
21764 };
21765
21766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21768 if (SWIG_arg_fail(1)) SWIG_fail;
21769 {
21770 PyThreadState* __tstate = wxPyBeginAllowThreads();
21771 result = (bool)wxIdleEvent::CanSend(arg1);
21772
21773 wxPyEndAllowThreads(__tstate);
21774 if (PyErr_Occurred()) SWIG_fail;
21775 }
21776 {
21777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21778 }
21779 return resultobj;
21780 fail:
21781 return NULL;
21782 }
21783
21784
21785 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21786 PyObject *obj;
21787 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21788 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21789 Py_INCREF(obj);
21790 return Py_BuildValue((char *)"");
21791 }
21792 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21793 PyObject *resultobj;
21794 int arg1 = (int) 0 ;
21795 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21796 wxPyEvent *result;
21797 PyObject * obj0 = 0 ;
21798 PyObject * obj1 = 0 ;
21799 char *kwnames[] = {
21800 (char *) "winid",(char *) "commandType", NULL
21801 };
21802
21803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21804 if (obj0) {
21805 {
21806 arg1 = (int)(SWIG_As_int(obj0));
21807 if (SWIG_arg_fail(1)) SWIG_fail;
21808 }
21809 }
21810 if (obj1) {
21811 {
21812 arg2 = (wxEventType)(SWIG_As_int(obj1));
21813 if (SWIG_arg_fail(2)) SWIG_fail;
21814 }
21815 }
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21819
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21824 return resultobj;
21825 fail:
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj;
21832 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21833 PyObject * obj0 = 0 ;
21834 char *kwnames[] = {
21835 (char *) "self", NULL
21836 };
21837
21838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21840 if (SWIG_arg_fail(1)) SWIG_fail;
21841 {
21842 PyThreadState* __tstate = wxPyBeginAllowThreads();
21843 delete arg1;
21844
21845 wxPyEndAllowThreads(__tstate);
21846 if (PyErr_Occurred()) SWIG_fail;
21847 }
21848 Py_INCREF(Py_None); resultobj = Py_None;
21849 return resultobj;
21850 fail:
21851 return NULL;
21852 }
21853
21854
21855 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21856 PyObject *resultobj;
21857 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21858 PyObject *arg2 = (PyObject *) 0 ;
21859 PyObject * obj0 = 0 ;
21860 PyObject * obj1 = 0 ;
21861 char *kwnames[] = {
21862 (char *) "self",(char *) "self", NULL
21863 };
21864
21865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21867 if (SWIG_arg_fail(1)) SWIG_fail;
21868 arg2 = obj1;
21869 {
21870 PyThreadState* __tstate = wxPyBeginAllowThreads();
21871 (arg1)->SetSelf(arg2);
21872
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 Py_INCREF(Py_None); resultobj = Py_None;
21877 return resultobj;
21878 fail:
21879 return NULL;
21880 }
21881
21882
21883 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21884 PyObject *resultobj;
21885 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21886 PyObject *result;
21887 PyObject * obj0 = 0 ;
21888 char *kwnames[] = {
21889 (char *) "self", NULL
21890 };
21891
21892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21894 if (SWIG_arg_fail(1)) SWIG_fail;
21895 {
21896 PyThreadState* __tstate = wxPyBeginAllowThreads();
21897 result = (PyObject *)(arg1)->GetSelf();
21898
21899 wxPyEndAllowThreads(__tstate);
21900 if (PyErr_Occurred()) SWIG_fail;
21901 }
21902 resultobj = result;
21903 return resultobj;
21904 fail:
21905 return NULL;
21906 }
21907
21908
21909 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21910 PyObject *obj;
21911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21912 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21913 Py_INCREF(obj);
21914 return Py_BuildValue((char *)"");
21915 }
21916 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj;
21918 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21919 int arg2 = (int) 0 ;
21920 wxPyCommandEvent *result;
21921 PyObject * obj0 = 0 ;
21922 PyObject * obj1 = 0 ;
21923 char *kwnames[] = {
21924 (char *) "commandType",(char *) "id", NULL
21925 };
21926
21927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21928 if (obj0) {
21929 {
21930 arg1 = (wxEventType)(SWIG_As_int(obj0));
21931 if (SWIG_arg_fail(1)) SWIG_fail;
21932 }
21933 }
21934 if (obj1) {
21935 {
21936 arg2 = (int)(SWIG_As_int(obj1));
21937 if (SWIG_arg_fail(2)) SWIG_fail;
21938 }
21939 }
21940 {
21941 PyThreadState* __tstate = wxPyBeginAllowThreads();
21942 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21943
21944 wxPyEndAllowThreads(__tstate);
21945 if (PyErr_Occurred()) SWIG_fail;
21946 }
21947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21948 return resultobj;
21949 fail:
21950 return NULL;
21951 }
21952
21953
21954 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21955 PyObject *resultobj;
21956 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21957 PyObject * obj0 = 0 ;
21958 char *kwnames[] = {
21959 (char *) "self", NULL
21960 };
21961
21962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21964 if (SWIG_arg_fail(1)) SWIG_fail;
21965 {
21966 PyThreadState* __tstate = wxPyBeginAllowThreads();
21967 delete arg1;
21968
21969 wxPyEndAllowThreads(__tstate);
21970 if (PyErr_Occurred()) SWIG_fail;
21971 }
21972 Py_INCREF(Py_None); resultobj = Py_None;
21973 return resultobj;
21974 fail:
21975 return NULL;
21976 }
21977
21978
21979 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj;
21981 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21982 PyObject *arg2 = (PyObject *) 0 ;
21983 PyObject * obj0 = 0 ;
21984 PyObject * obj1 = 0 ;
21985 char *kwnames[] = {
21986 (char *) "self",(char *) "self", NULL
21987 };
21988
21989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21991 if (SWIG_arg_fail(1)) SWIG_fail;
21992 arg2 = obj1;
21993 {
21994 PyThreadState* __tstate = wxPyBeginAllowThreads();
21995 (arg1)->SetSelf(arg2);
21996
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 Py_INCREF(Py_None); resultobj = Py_None;
22001 return resultobj;
22002 fail:
22003 return NULL;
22004 }
22005
22006
22007 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22008 PyObject *resultobj;
22009 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22010 PyObject *result;
22011 PyObject * obj0 = 0 ;
22012 char *kwnames[] = {
22013 (char *) "self", NULL
22014 };
22015
22016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22018 if (SWIG_arg_fail(1)) SWIG_fail;
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (PyObject *)(arg1)->GetSelf();
22022
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 resultobj = result;
22027 return resultobj;
22028 fail:
22029 return NULL;
22030 }
22031
22032
22033 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22034 PyObject *obj;
22035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22036 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22037 Py_INCREF(obj);
22038 return Py_BuildValue((char *)"");
22039 }
22040 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22041 PyObject *resultobj;
22042 wxWindow *arg1 = (wxWindow *) 0 ;
22043 wxDateTime *arg2 = 0 ;
22044 wxEventType arg3 ;
22045 wxDateEvent *result;
22046 PyObject * obj0 = 0 ;
22047 PyObject * obj1 = 0 ;
22048 PyObject * obj2 = 0 ;
22049 char *kwnames[] = {
22050 (char *) "win",(char *) "dt",(char *) "type", NULL
22051 };
22052
22053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22055 if (SWIG_arg_fail(1)) SWIG_fail;
22056 {
22057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22058 if (SWIG_arg_fail(2)) SWIG_fail;
22059 if (arg2 == NULL) {
22060 SWIG_null_ref("wxDateTime");
22061 }
22062 if (SWIG_arg_fail(2)) SWIG_fail;
22063 }
22064 {
22065 arg3 = (wxEventType)(SWIG_As_int(obj2));
22066 if (SWIG_arg_fail(3)) SWIG_fail;
22067 }
22068 {
22069 PyThreadState* __tstate = wxPyBeginAllowThreads();
22070 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22071
22072 wxPyEndAllowThreads(__tstate);
22073 if (PyErr_Occurred()) SWIG_fail;
22074 }
22075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22076 return resultobj;
22077 fail:
22078 return NULL;
22079 }
22080
22081
22082 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22083 PyObject *resultobj;
22084 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22085 wxDateTime *result;
22086 PyObject * obj0 = 0 ;
22087 char *kwnames[] = {
22088 (char *) "self", NULL
22089 };
22090
22091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22093 if (SWIG_arg_fail(1)) SWIG_fail;
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 {
22097 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22098 result = (wxDateTime *) &_result_ref;
22099 }
22100
22101 wxPyEndAllowThreads(__tstate);
22102 if (PyErr_Occurred()) SWIG_fail;
22103 }
22104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22105 return resultobj;
22106 fail:
22107 return NULL;
22108 }
22109
22110
22111 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22112 PyObject *resultobj;
22113 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22114 wxDateTime *arg2 = 0 ;
22115 PyObject * obj0 = 0 ;
22116 PyObject * obj1 = 0 ;
22117 char *kwnames[] = {
22118 (char *) "self",(char *) "date", NULL
22119 };
22120
22121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22123 if (SWIG_arg_fail(1)) SWIG_fail;
22124 {
22125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22126 if (SWIG_arg_fail(2)) SWIG_fail;
22127 if (arg2 == NULL) {
22128 SWIG_null_ref("wxDateTime");
22129 }
22130 if (SWIG_arg_fail(2)) SWIG_fail;
22131 }
22132 {
22133 PyThreadState* __tstate = wxPyBeginAllowThreads();
22134 (arg1)->SetDate((wxDateTime const &)*arg2);
22135
22136 wxPyEndAllowThreads(__tstate);
22137 if (PyErr_Occurred()) SWIG_fail;
22138 }
22139 Py_INCREF(Py_None); resultobj = Py_None;
22140 return resultobj;
22141 fail:
22142 return NULL;
22143 }
22144
22145
22146 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22147 PyObject *obj;
22148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22149 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22150 Py_INCREF(obj);
22151 return Py_BuildValue((char *)"");
22152 }
22153 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22154 PyObject *resultobj;
22155 wxPyApp *result;
22156 char *kwnames[] = {
22157 NULL
22158 };
22159
22160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 result = (wxPyApp *)new_wxPyApp();
22164
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22169 return resultobj;
22170 fail:
22171 return NULL;
22172 }
22173
22174
22175 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22176 PyObject *resultobj;
22177 wxPyApp *arg1 = (wxPyApp *) 0 ;
22178 PyObject * obj0 = 0 ;
22179 char *kwnames[] = {
22180 (char *) "self", NULL
22181 };
22182
22183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22185 if (SWIG_arg_fail(1)) SWIG_fail;
22186 {
22187 PyThreadState* __tstate = wxPyBeginAllowThreads();
22188 delete arg1;
22189
22190 wxPyEndAllowThreads(__tstate);
22191 if (PyErr_Occurred()) SWIG_fail;
22192 }
22193 Py_INCREF(Py_None); resultobj = Py_None;
22194 return resultobj;
22195 fail:
22196 return NULL;
22197 }
22198
22199
22200 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22201 PyObject *resultobj;
22202 wxPyApp *arg1 = (wxPyApp *) 0 ;
22203 PyObject *arg2 = (PyObject *) 0 ;
22204 PyObject *arg3 = (PyObject *) 0 ;
22205 PyObject * obj0 = 0 ;
22206 PyObject * obj1 = 0 ;
22207 PyObject * obj2 = 0 ;
22208 char *kwnames[] = {
22209 (char *) "self",(char *) "self",(char *) "_class", NULL
22210 };
22211
22212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22214 if (SWIG_arg_fail(1)) SWIG_fail;
22215 arg2 = obj1;
22216 arg3 = obj2;
22217 {
22218 PyThreadState* __tstate = wxPyBeginAllowThreads();
22219 (arg1)->_setCallbackInfo(arg2,arg3);
22220
22221 wxPyEndAllowThreads(__tstate);
22222 if (PyErr_Occurred()) SWIG_fail;
22223 }
22224 Py_INCREF(Py_None); resultobj = Py_None;
22225 return resultobj;
22226 fail:
22227 return NULL;
22228 }
22229
22230
22231 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22232 PyObject *resultobj;
22233 wxPyApp *arg1 = (wxPyApp *) 0 ;
22234 wxString result;
22235 PyObject * obj0 = 0 ;
22236 char *kwnames[] = {
22237 (char *) "self", NULL
22238 };
22239
22240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22242 if (SWIG_arg_fail(1)) SWIG_fail;
22243 {
22244 PyThreadState* __tstate = wxPyBeginAllowThreads();
22245 result = ((wxPyApp const *)arg1)->GetAppName();
22246
22247 wxPyEndAllowThreads(__tstate);
22248 if (PyErr_Occurred()) SWIG_fail;
22249 }
22250 {
22251 #if wxUSE_UNICODE
22252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22253 #else
22254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22255 #endif
22256 }
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj;
22265 wxPyApp *arg1 = (wxPyApp *) 0 ;
22266 wxString *arg2 = 0 ;
22267 bool temp2 = false ;
22268 PyObject * obj0 = 0 ;
22269 PyObject * obj1 = 0 ;
22270 char *kwnames[] = {
22271 (char *) "self",(char *) "name", NULL
22272 };
22273
22274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22276 if (SWIG_arg_fail(1)) SWIG_fail;
22277 {
22278 arg2 = wxString_in_helper(obj1);
22279 if (arg2 == NULL) SWIG_fail;
22280 temp2 = true;
22281 }
22282 {
22283 PyThreadState* __tstate = wxPyBeginAllowThreads();
22284 (arg1)->SetAppName((wxString const &)*arg2);
22285
22286 wxPyEndAllowThreads(__tstate);
22287 if (PyErr_Occurred()) SWIG_fail;
22288 }
22289 Py_INCREF(Py_None); resultobj = Py_None;
22290 {
22291 if (temp2)
22292 delete arg2;
22293 }
22294 return resultobj;
22295 fail:
22296 {
22297 if (temp2)
22298 delete arg2;
22299 }
22300 return NULL;
22301 }
22302
22303
22304 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj;
22306 wxPyApp *arg1 = (wxPyApp *) 0 ;
22307 wxString result;
22308 PyObject * obj0 = 0 ;
22309 char *kwnames[] = {
22310 (char *) "self", NULL
22311 };
22312
22313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22315 if (SWIG_arg_fail(1)) SWIG_fail;
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 result = ((wxPyApp const *)arg1)->GetClassName();
22319
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 {
22324 #if wxUSE_UNICODE
22325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22326 #else
22327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22328 #endif
22329 }
22330 return resultobj;
22331 fail:
22332 return NULL;
22333 }
22334
22335
22336 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22337 PyObject *resultobj;
22338 wxPyApp *arg1 = (wxPyApp *) 0 ;
22339 wxString *arg2 = 0 ;
22340 bool temp2 = false ;
22341 PyObject * obj0 = 0 ;
22342 PyObject * obj1 = 0 ;
22343 char *kwnames[] = {
22344 (char *) "self",(char *) "name", NULL
22345 };
22346
22347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22349 if (SWIG_arg_fail(1)) SWIG_fail;
22350 {
22351 arg2 = wxString_in_helper(obj1);
22352 if (arg2 == NULL) SWIG_fail;
22353 temp2 = true;
22354 }
22355 {
22356 PyThreadState* __tstate = wxPyBeginAllowThreads();
22357 (arg1)->SetClassName((wxString const &)*arg2);
22358
22359 wxPyEndAllowThreads(__tstate);
22360 if (PyErr_Occurred()) SWIG_fail;
22361 }
22362 Py_INCREF(Py_None); resultobj = Py_None;
22363 {
22364 if (temp2)
22365 delete arg2;
22366 }
22367 return resultobj;
22368 fail:
22369 {
22370 if (temp2)
22371 delete arg2;
22372 }
22373 return NULL;
22374 }
22375
22376
22377 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22378 PyObject *resultobj;
22379 wxPyApp *arg1 = (wxPyApp *) 0 ;
22380 wxString *result;
22381 PyObject * obj0 = 0 ;
22382 char *kwnames[] = {
22383 (char *) "self", NULL
22384 };
22385
22386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22388 if (SWIG_arg_fail(1)) SWIG_fail;
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 {
22392 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22393 result = (wxString *) &_result_ref;
22394 }
22395
22396 wxPyEndAllowThreads(__tstate);
22397 if (PyErr_Occurred()) SWIG_fail;
22398 }
22399 {
22400 #if wxUSE_UNICODE
22401 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22402 #else
22403 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22404 #endif
22405 }
22406 return resultobj;
22407 fail:
22408 return NULL;
22409 }
22410
22411
22412 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22413 PyObject *resultobj;
22414 wxPyApp *arg1 = (wxPyApp *) 0 ;
22415 wxString *arg2 = 0 ;
22416 bool temp2 = false ;
22417 PyObject * obj0 = 0 ;
22418 PyObject * obj1 = 0 ;
22419 char *kwnames[] = {
22420 (char *) "self",(char *) "name", NULL
22421 };
22422
22423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22425 if (SWIG_arg_fail(1)) SWIG_fail;
22426 {
22427 arg2 = wxString_in_helper(obj1);
22428 if (arg2 == NULL) SWIG_fail;
22429 temp2 = true;
22430 }
22431 {
22432 PyThreadState* __tstate = wxPyBeginAllowThreads();
22433 (arg1)->SetVendorName((wxString const &)*arg2);
22434
22435 wxPyEndAllowThreads(__tstate);
22436 if (PyErr_Occurred()) SWIG_fail;
22437 }
22438 Py_INCREF(Py_None); resultobj = Py_None;
22439 {
22440 if (temp2)
22441 delete arg2;
22442 }
22443 return resultobj;
22444 fail:
22445 {
22446 if (temp2)
22447 delete arg2;
22448 }
22449 return NULL;
22450 }
22451
22452
22453 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22454 PyObject *resultobj;
22455 wxPyApp *arg1 = (wxPyApp *) 0 ;
22456 wxAppTraits *result;
22457 PyObject * obj0 = 0 ;
22458 char *kwnames[] = {
22459 (char *) "self", NULL
22460 };
22461
22462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22464 if (SWIG_arg_fail(1)) SWIG_fail;
22465 {
22466 PyThreadState* __tstate = wxPyBeginAllowThreads();
22467 result = (wxAppTraits *)(arg1)->GetTraits();
22468
22469 wxPyEndAllowThreads(__tstate);
22470 if (PyErr_Occurred()) SWIG_fail;
22471 }
22472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22480 PyObject *resultobj;
22481 wxPyApp *arg1 = (wxPyApp *) 0 ;
22482 PyObject * obj0 = 0 ;
22483 char *kwnames[] = {
22484 (char *) "self", NULL
22485 };
22486
22487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22489 if (SWIG_arg_fail(1)) SWIG_fail;
22490 {
22491 PyThreadState* __tstate = wxPyBeginAllowThreads();
22492 (arg1)->ProcessPendingEvents();
22493
22494 wxPyEndAllowThreads(__tstate);
22495 if (PyErr_Occurred()) SWIG_fail;
22496 }
22497 Py_INCREF(Py_None); resultobj = Py_None;
22498 return resultobj;
22499 fail:
22500 return NULL;
22501 }
22502
22503
22504 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22505 PyObject *resultobj;
22506 wxPyApp *arg1 = (wxPyApp *) 0 ;
22507 bool arg2 = (bool) false ;
22508 bool result;
22509 PyObject * obj0 = 0 ;
22510 PyObject * obj1 = 0 ;
22511 char *kwnames[] = {
22512 (char *) "self",(char *) "onlyIfNeeded", NULL
22513 };
22514
22515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22517 if (SWIG_arg_fail(1)) SWIG_fail;
22518 if (obj1) {
22519 {
22520 arg2 = (bool)(SWIG_As_bool(obj1));
22521 if (SWIG_arg_fail(2)) SWIG_fail;
22522 }
22523 }
22524 {
22525 PyThreadState* __tstate = wxPyBeginAllowThreads();
22526 result = (bool)(arg1)->Yield(arg2);
22527
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 {
22532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22533 }
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22541 PyObject *resultobj;
22542 wxPyApp *arg1 = (wxPyApp *) 0 ;
22543 PyObject * obj0 = 0 ;
22544 char *kwnames[] = {
22545 (char *) "self", NULL
22546 };
22547
22548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22550 if (SWIG_arg_fail(1)) SWIG_fail;
22551 {
22552 PyThreadState* __tstate = wxPyBeginAllowThreads();
22553 (arg1)->WakeUpIdle();
22554
22555 wxPyEndAllowThreads(__tstate);
22556 if (PyErr_Occurred()) SWIG_fail;
22557 }
22558 Py_INCREF(Py_None); resultobj = Py_None;
22559 return resultobj;
22560 fail:
22561 return NULL;
22562 }
22563
22564
22565 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22566 PyObject *resultobj;
22567 bool result;
22568 char *kwnames[] = {
22569 NULL
22570 };
22571
22572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22573 {
22574 PyThreadState* __tstate = wxPyBeginAllowThreads();
22575 result = (bool)wxPyApp::IsMainLoopRunning();
22576
22577 wxPyEndAllowThreads(__tstate);
22578 if (PyErr_Occurred()) SWIG_fail;
22579 }
22580 {
22581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22582 }
22583 return resultobj;
22584 fail:
22585 return NULL;
22586 }
22587
22588
22589 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22590 PyObject *resultobj;
22591 wxPyApp *arg1 = (wxPyApp *) 0 ;
22592 int result;
22593 PyObject * obj0 = 0 ;
22594 char *kwnames[] = {
22595 (char *) "self", NULL
22596 };
22597
22598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22600 if (SWIG_arg_fail(1)) SWIG_fail;
22601 {
22602 PyThreadState* __tstate = wxPyBeginAllowThreads();
22603 result = (int)(arg1)->MainLoop();
22604
22605 wxPyEndAllowThreads(__tstate);
22606 if (PyErr_Occurred()) SWIG_fail;
22607 }
22608 {
22609 resultobj = SWIG_From_int((int)(result));
22610 }
22611 return resultobj;
22612 fail:
22613 return NULL;
22614 }
22615
22616
22617 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22618 PyObject *resultobj;
22619 wxPyApp *arg1 = (wxPyApp *) 0 ;
22620 PyObject * obj0 = 0 ;
22621 char *kwnames[] = {
22622 (char *) "self", NULL
22623 };
22624
22625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22627 if (SWIG_arg_fail(1)) SWIG_fail;
22628 {
22629 PyThreadState* __tstate = wxPyBeginAllowThreads();
22630 (arg1)->Exit();
22631
22632 wxPyEndAllowThreads(__tstate);
22633 if (PyErr_Occurred()) SWIG_fail;
22634 }
22635 Py_INCREF(Py_None); resultobj = Py_None;
22636 return resultobj;
22637 fail:
22638 return NULL;
22639 }
22640
22641
22642 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22643 PyObject *resultobj;
22644 wxPyApp *arg1 = (wxPyApp *) 0 ;
22645 PyObject * obj0 = 0 ;
22646 char *kwnames[] = {
22647 (char *) "self", NULL
22648 };
22649
22650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22652 if (SWIG_arg_fail(1)) SWIG_fail;
22653 {
22654 PyThreadState* __tstate = wxPyBeginAllowThreads();
22655 (arg1)->ExitMainLoop();
22656
22657 wxPyEndAllowThreads(__tstate);
22658 if (PyErr_Occurred()) SWIG_fail;
22659 }
22660 Py_INCREF(Py_None); resultobj = Py_None;
22661 return resultobj;
22662 fail:
22663 return NULL;
22664 }
22665
22666
22667 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22668 PyObject *resultobj;
22669 wxPyApp *arg1 = (wxPyApp *) 0 ;
22670 bool result;
22671 PyObject * obj0 = 0 ;
22672 char *kwnames[] = {
22673 (char *) "self", NULL
22674 };
22675
22676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22678 if (SWIG_arg_fail(1)) SWIG_fail;
22679 {
22680 PyThreadState* __tstate = wxPyBeginAllowThreads();
22681 result = (bool)(arg1)->Pending();
22682
22683 wxPyEndAllowThreads(__tstate);
22684 if (PyErr_Occurred()) SWIG_fail;
22685 }
22686 {
22687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22688 }
22689 return resultobj;
22690 fail:
22691 return NULL;
22692 }
22693
22694
22695 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22696 PyObject *resultobj;
22697 wxPyApp *arg1 = (wxPyApp *) 0 ;
22698 bool result;
22699 PyObject * obj0 = 0 ;
22700 char *kwnames[] = {
22701 (char *) "self", NULL
22702 };
22703
22704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22706 if (SWIG_arg_fail(1)) SWIG_fail;
22707 {
22708 PyThreadState* __tstate = wxPyBeginAllowThreads();
22709 result = (bool)(arg1)->Dispatch();
22710
22711 wxPyEndAllowThreads(__tstate);
22712 if (PyErr_Occurred()) SWIG_fail;
22713 }
22714 {
22715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22716 }
22717 return resultobj;
22718 fail:
22719 return NULL;
22720 }
22721
22722
22723 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22724 PyObject *resultobj;
22725 wxPyApp *arg1 = (wxPyApp *) 0 ;
22726 bool result;
22727 PyObject * obj0 = 0 ;
22728 char *kwnames[] = {
22729 (char *) "self", NULL
22730 };
22731
22732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22734 if (SWIG_arg_fail(1)) SWIG_fail;
22735 {
22736 PyThreadState* __tstate = wxPyBeginAllowThreads();
22737 result = (bool)(arg1)->ProcessIdle();
22738
22739 wxPyEndAllowThreads(__tstate);
22740 if (PyErr_Occurred()) SWIG_fail;
22741 }
22742 {
22743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22744 }
22745 return resultobj;
22746 fail:
22747 return NULL;
22748 }
22749
22750
22751 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22752 PyObject *resultobj;
22753 wxPyApp *arg1 = (wxPyApp *) 0 ;
22754 wxWindow *arg2 = (wxWindow *) 0 ;
22755 wxIdleEvent *arg3 = 0 ;
22756 bool result;
22757 PyObject * obj0 = 0 ;
22758 PyObject * obj1 = 0 ;
22759 PyObject * obj2 = 0 ;
22760 char *kwnames[] = {
22761 (char *) "self",(char *) "win",(char *) "event", NULL
22762 };
22763
22764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22766 if (SWIG_arg_fail(1)) SWIG_fail;
22767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22768 if (SWIG_arg_fail(2)) SWIG_fail;
22769 {
22770 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22771 if (SWIG_arg_fail(3)) SWIG_fail;
22772 if (arg3 == NULL) {
22773 SWIG_null_ref("wxIdleEvent");
22774 }
22775 if (SWIG_arg_fail(3)) SWIG_fail;
22776 }
22777 {
22778 PyThreadState* __tstate = wxPyBeginAllowThreads();
22779 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22780
22781 wxPyEndAllowThreads(__tstate);
22782 if (PyErr_Occurred()) SWIG_fail;
22783 }
22784 {
22785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22786 }
22787 return resultobj;
22788 fail:
22789 return NULL;
22790 }
22791
22792
22793 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22794 PyObject *resultobj;
22795 wxPyApp *arg1 = (wxPyApp *) 0 ;
22796 bool result;
22797 PyObject * obj0 = 0 ;
22798 char *kwnames[] = {
22799 (char *) "self", NULL
22800 };
22801
22802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22804 if (SWIG_arg_fail(1)) SWIG_fail;
22805 {
22806 PyThreadState* __tstate = wxPyBeginAllowThreads();
22807 result = (bool)((wxPyApp const *)arg1)->IsActive();
22808
22809 wxPyEndAllowThreads(__tstate);
22810 if (PyErr_Occurred()) SWIG_fail;
22811 }
22812 {
22813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22814 }
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22822 PyObject *resultobj;
22823 wxPyApp *arg1 = (wxPyApp *) 0 ;
22824 wxWindow *arg2 = (wxWindow *) 0 ;
22825 PyObject * obj0 = 0 ;
22826 PyObject * obj1 = 0 ;
22827 char *kwnames[] = {
22828 (char *) "self",(char *) "win", NULL
22829 };
22830
22831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22833 if (SWIG_arg_fail(1)) SWIG_fail;
22834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22835 if (SWIG_arg_fail(2)) SWIG_fail;
22836 {
22837 PyThreadState* __tstate = wxPyBeginAllowThreads();
22838 (arg1)->SetTopWindow(arg2);
22839
22840 wxPyEndAllowThreads(__tstate);
22841 if (PyErr_Occurred()) SWIG_fail;
22842 }
22843 Py_INCREF(Py_None); resultobj = Py_None;
22844 return resultobj;
22845 fail:
22846 return NULL;
22847 }
22848
22849
22850 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22851 PyObject *resultobj;
22852 wxPyApp *arg1 = (wxPyApp *) 0 ;
22853 wxWindow *result;
22854 PyObject * obj0 = 0 ;
22855 char *kwnames[] = {
22856 (char *) "self", NULL
22857 };
22858
22859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22861 if (SWIG_arg_fail(1)) SWIG_fail;
22862 {
22863 PyThreadState* __tstate = wxPyBeginAllowThreads();
22864 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22865
22866 wxPyEndAllowThreads(__tstate);
22867 if (PyErr_Occurred()) SWIG_fail;
22868 }
22869 {
22870 resultobj = wxPyMake_wxObject(result, 0);
22871 }
22872 return resultobj;
22873 fail:
22874 return NULL;
22875 }
22876
22877
22878 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22879 PyObject *resultobj;
22880 wxPyApp *arg1 = (wxPyApp *) 0 ;
22881 bool arg2 ;
22882 PyObject * obj0 = 0 ;
22883 PyObject * obj1 = 0 ;
22884 char *kwnames[] = {
22885 (char *) "self",(char *) "flag", NULL
22886 };
22887
22888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22890 if (SWIG_arg_fail(1)) SWIG_fail;
22891 {
22892 arg2 = (bool)(SWIG_As_bool(obj1));
22893 if (SWIG_arg_fail(2)) SWIG_fail;
22894 }
22895 {
22896 PyThreadState* __tstate = wxPyBeginAllowThreads();
22897 (arg1)->SetExitOnFrameDelete(arg2);
22898
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 Py_INCREF(Py_None); resultobj = Py_None;
22903 return resultobj;
22904 fail:
22905 return NULL;
22906 }
22907
22908
22909 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22910 PyObject *resultobj;
22911 wxPyApp *arg1 = (wxPyApp *) 0 ;
22912 bool result;
22913 PyObject * obj0 = 0 ;
22914 char *kwnames[] = {
22915 (char *) "self", NULL
22916 };
22917
22918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
22923 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22924
22925 wxPyEndAllowThreads(__tstate);
22926 if (PyErr_Occurred()) SWIG_fail;
22927 }
22928 {
22929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22930 }
22931 return resultobj;
22932 fail:
22933 return NULL;
22934 }
22935
22936
22937 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22938 PyObject *resultobj;
22939 wxPyApp *arg1 = (wxPyApp *) 0 ;
22940 bool arg2 ;
22941 PyObject * obj0 = 0 ;
22942 PyObject * obj1 = 0 ;
22943 char *kwnames[] = {
22944 (char *) "self",(char *) "flag", NULL
22945 };
22946
22947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22949 if (SWIG_arg_fail(1)) SWIG_fail;
22950 {
22951 arg2 = (bool)(SWIG_As_bool(obj1));
22952 if (SWIG_arg_fail(2)) SWIG_fail;
22953 }
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 (arg1)->SetUseBestVisual(arg2);
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 Py_INCREF(Py_None); resultobj = Py_None;
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj;
22970 wxPyApp *arg1 = (wxPyApp *) 0 ;
22971 bool result;
22972 PyObject * obj0 = 0 ;
22973 char *kwnames[] = {
22974 (char *) "self", NULL
22975 };
22976
22977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22979 if (SWIG_arg_fail(1)) SWIG_fail;
22980 {
22981 PyThreadState* __tstate = wxPyBeginAllowThreads();
22982 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22983
22984 wxPyEndAllowThreads(__tstate);
22985 if (PyErr_Occurred()) SWIG_fail;
22986 }
22987 {
22988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22989 }
22990 return resultobj;
22991 fail:
22992 return NULL;
22993 }
22994
22995
22996 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22997 PyObject *resultobj;
22998 wxPyApp *arg1 = (wxPyApp *) 0 ;
22999 int arg2 ;
23000 PyObject * obj0 = 0 ;
23001 PyObject * obj1 = 0 ;
23002 char *kwnames[] = {
23003 (char *) "self",(char *) "mode", NULL
23004 };
23005
23006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23008 if (SWIG_arg_fail(1)) SWIG_fail;
23009 {
23010 arg2 = (int)(SWIG_As_int(obj1));
23011 if (SWIG_arg_fail(2)) SWIG_fail;
23012 }
23013 {
23014 PyThreadState* __tstate = wxPyBeginAllowThreads();
23015 (arg1)->SetPrintMode(arg2);
23016
23017 wxPyEndAllowThreads(__tstate);
23018 if (PyErr_Occurred()) SWIG_fail;
23019 }
23020 Py_INCREF(Py_None); resultobj = Py_None;
23021 return resultobj;
23022 fail:
23023 return NULL;
23024 }
23025
23026
23027 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23028 PyObject *resultobj;
23029 wxPyApp *arg1 = (wxPyApp *) 0 ;
23030 int result;
23031 PyObject * obj0 = 0 ;
23032 char *kwnames[] = {
23033 (char *) "self", NULL
23034 };
23035
23036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23038 if (SWIG_arg_fail(1)) SWIG_fail;
23039 {
23040 PyThreadState* __tstate = wxPyBeginAllowThreads();
23041 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23042
23043 wxPyEndAllowThreads(__tstate);
23044 if (PyErr_Occurred()) SWIG_fail;
23045 }
23046 {
23047 resultobj = SWIG_From_int((int)(result));
23048 }
23049 return resultobj;
23050 fail:
23051 return NULL;
23052 }
23053
23054
23055 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23056 PyObject *resultobj;
23057 wxPyApp *arg1 = (wxPyApp *) 0 ;
23058 int arg2 ;
23059 PyObject * obj0 = 0 ;
23060 PyObject * obj1 = 0 ;
23061 char *kwnames[] = {
23062 (char *) "self",(char *) "mode", NULL
23063 };
23064
23065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23067 if (SWIG_arg_fail(1)) SWIG_fail;
23068 {
23069 arg2 = (int)(SWIG_As_int(obj1));
23070 if (SWIG_arg_fail(2)) SWIG_fail;
23071 }
23072 {
23073 PyThreadState* __tstate = wxPyBeginAllowThreads();
23074 (arg1)->SetAssertMode(arg2);
23075
23076 wxPyEndAllowThreads(__tstate);
23077 if (PyErr_Occurred()) SWIG_fail;
23078 }
23079 Py_INCREF(Py_None); resultobj = Py_None;
23080 return resultobj;
23081 fail:
23082 return NULL;
23083 }
23084
23085
23086 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23087 PyObject *resultobj;
23088 wxPyApp *arg1 = (wxPyApp *) 0 ;
23089 int result;
23090 PyObject * obj0 = 0 ;
23091 char *kwnames[] = {
23092 (char *) "self", NULL
23093 };
23094
23095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23097 if (SWIG_arg_fail(1)) SWIG_fail;
23098 {
23099 PyThreadState* __tstate = wxPyBeginAllowThreads();
23100 result = (int)(arg1)->GetAssertMode();
23101
23102 wxPyEndAllowThreads(__tstate);
23103 if (PyErr_Occurred()) SWIG_fail;
23104 }
23105 {
23106 resultobj = SWIG_From_int((int)(result));
23107 }
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23115 PyObject *resultobj;
23116 bool result;
23117 char *kwnames[] = {
23118 NULL
23119 };
23120
23121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23125
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 {
23130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23131 }
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj;
23140 long result;
23141 char *kwnames[] = {
23142 NULL
23143 };
23144
23145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23146 {
23147 PyThreadState* __tstate = wxPyBeginAllowThreads();
23148 result = (long)wxPyApp::GetMacAboutMenuItemId();
23149
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 {
23154 resultobj = SWIG_From_long((long)(result));
23155 }
23156 return resultobj;
23157 fail:
23158 return NULL;
23159 }
23160
23161
23162 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23163 PyObject *resultobj;
23164 long result;
23165 char *kwnames[] = {
23166 NULL
23167 };
23168
23169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23170 {
23171 PyThreadState* __tstate = wxPyBeginAllowThreads();
23172 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23173
23174 wxPyEndAllowThreads(__tstate);
23175 if (PyErr_Occurred()) SWIG_fail;
23176 }
23177 {
23178 resultobj = SWIG_From_long((long)(result));
23179 }
23180 return resultobj;
23181 fail:
23182 return NULL;
23183 }
23184
23185
23186 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23187 PyObject *resultobj;
23188 long result;
23189 char *kwnames[] = {
23190 NULL
23191 };
23192
23193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23194 {
23195 PyThreadState* __tstate = wxPyBeginAllowThreads();
23196 result = (long)wxPyApp::GetMacExitMenuItemId();
23197
23198 wxPyEndAllowThreads(__tstate);
23199 if (PyErr_Occurred()) SWIG_fail;
23200 }
23201 {
23202 resultobj = SWIG_From_long((long)(result));
23203 }
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23211 PyObject *resultobj;
23212 wxString result;
23213 char *kwnames[] = {
23214 NULL
23215 };
23216
23217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23218 {
23219 PyThreadState* __tstate = wxPyBeginAllowThreads();
23220 result = wxPyApp::GetMacHelpMenuTitleName();
23221
23222 wxPyEndAllowThreads(__tstate);
23223 if (PyErr_Occurred()) SWIG_fail;
23224 }
23225 {
23226 #if wxUSE_UNICODE
23227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23228 #else
23229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23230 #endif
23231 }
23232 return resultobj;
23233 fail:
23234 return NULL;
23235 }
23236
23237
23238 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23239 PyObject *resultobj;
23240 bool arg1 ;
23241 PyObject * obj0 = 0 ;
23242 char *kwnames[] = {
23243 (char *) "val", NULL
23244 };
23245
23246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23247 {
23248 arg1 = (bool)(SWIG_As_bool(obj0));
23249 if (SWIG_arg_fail(1)) SWIG_fail;
23250 }
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23254
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 Py_INCREF(Py_None); resultobj = Py_None;
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23266 PyObject *resultobj;
23267 long arg1 ;
23268 PyObject * obj0 = 0 ;
23269 char *kwnames[] = {
23270 (char *) "val", NULL
23271 };
23272
23273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23274 {
23275 arg1 = (long)(SWIG_As_long(obj0));
23276 if (SWIG_arg_fail(1)) SWIG_fail;
23277 }
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 wxPyApp::SetMacAboutMenuItemId(arg1);
23281
23282 wxPyEndAllowThreads(__tstate);
23283 if (PyErr_Occurred()) SWIG_fail;
23284 }
23285 Py_INCREF(Py_None); resultobj = Py_None;
23286 return resultobj;
23287 fail:
23288 return NULL;
23289 }
23290
23291
23292 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23293 PyObject *resultobj;
23294 long arg1 ;
23295 PyObject * obj0 = 0 ;
23296 char *kwnames[] = {
23297 (char *) "val", NULL
23298 };
23299
23300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23301 {
23302 arg1 = (long)(SWIG_As_long(obj0));
23303 if (SWIG_arg_fail(1)) SWIG_fail;
23304 }
23305 {
23306 PyThreadState* __tstate = wxPyBeginAllowThreads();
23307 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23308
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 Py_INCREF(Py_None); resultobj = Py_None;
23313 return resultobj;
23314 fail:
23315 return NULL;
23316 }
23317
23318
23319 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23320 PyObject *resultobj;
23321 long arg1 ;
23322 PyObject * obj0 = 0 ;
23323 char *kwnames[] = {
23324 (char *) "val", NULL
23325 };
23326
23327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23328 {
23329 arg1 = (long)(SWIG_As_long(obj0));
23330 if (SWIG_arg_fail(1)) SWIG_fail;
23331 }
23332 {
23333 PyThreadState* __tstate = wxPyBeginAllowThreads();
23334 wxPyApp::SetMacExitMenuItemId(arg1);
23335
23336 wxPyEndAllowThreads(__tstate);
23337 if (PyErr_Occurred()) SWIG_fail;
23338 }
23339 Py_INCREF(Py_None); resultobj = Py_None;
23340 return resultobj;
23341 fail:
23342 return NULL;
23343 }
23344
23345
23346 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23347 PyObject *resultobj;
23348 wxString *arg1 = 0 ;
23349 bool temp1 = false ;
23350 PyObject * obj0 = 0 ;
23351 char *kwnames[] = {
23352 (char *) "val", NULL
23353 };
23354
23355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23356 {
23357 arg1 = wxString_in_helper(obj0);
23358 if (arg1 == NULL) SWIG_fail;
23359 temp1 = true;
23360 }
23361 {
23362 PyThreadState* __tstate = wxPyBeginAllowThreads();
23363 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23364
23365 wxPyEndAllowThreads(__tstate);
23366 if (PyErr_Occurred()) SWIG_fail;
23367 }
23368 Py_INCREF(Py_None); resultobj = Py_None;
23369 {
23370 if (temp1)
23371 delete arg1;
23372 }
23373 return resultobj;
23374 fail:
23375 {
23376 if (temp1)
23377 delete arg1;
23378 }
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 wxPyApp *arg1 = (wxPyApp *) 0 ;
23386 PyObject * obj0 = 0 ;
23387 char *kwnames[] = {
23388 (char *) "self", NULL
23389 };
23390
23391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23393 if (SWIG_arg_fail(1)) SWIG_fail;
23394 {
23395 PyThreadState* __tstate = wxPyBeginAllowThreads();
23396 (arg1)->_BootstrapApp();
23397
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 Py_INCREF(Py_None); resultobj = Py_None;
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23409 PyObject *resultobj;
23410 int result;
23411 char *kwnames[] = {
23412 NULL
23413 };
23414
23415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 result = (int)wxPyApp::GetComCtl32Version();
23419
23420 wxPyEndAllowThreads(__tstate);
23421 if (PyErr_Occurred()) SWIG_fail;
23422 }
23423 {
23424 resultobj = SWIG_From_int((int)(result));
23425 }
23426 return resultobj;
23427 fail:
23428 return NULL;
23429 }
23430
23431
23432 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23433 PyObject *obj;
23434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23435 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23436 Py_INCREF(obj);
23437 return Py_BuildValue((char *)"");
23438 }
23439 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23440 PyObject *resultobj;
23441 char *kwnames[] = {
23442 NULL
23443 };
23444
23445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 wxExit();
23449
23450 wxPyEndAllowThreads(__tstate);
23451 if (PyErr_Occurred()) SWIG_fail;
23452 }
23453 Py_INCREF(Py_None); resultobj = Py_None;
23454 return resultobj;
23455 fail:
23456 return NULL;
23457 }
23458
23459
23460 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23461 PyObject *resultobj;
23462 bool result;
23463 char *kwnames[] = {
23464 NULL
23465 };
23466
23467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23468 {
23469 PyThreadState* __tstate = wxPyBeginAllowThreads();
23470 result = (bool)wxYield();
23471
23472 wxPyEndAllowThreads(__tstate);
23473 if (PyErr_Occurred()) SWIG_fail;
23474 }
23475 {
23476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23477 }
23478 return resultobj;
23479 fail:
23480 return NULL;
23481 }
23482
23483
23484 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23485 PyObject *resultobj;
23486 bool result;
23487 char *kwnames[] = {
23488 NULL
23489 };
23490
23491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23492 {
23493 PyThreadState* __tstate = wxPyBeginAllowThreads();
23494 result = (bool)wxYieldIfNeeded();
23495
23496 wxPyEndAllowThreads(__tstate);
23497 if (PyErr_Occurred()) SWIG_fail;
23498 }
23499 {
23500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23501 }
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23509 PyObject *resultobj;
23510 wxWindow *arg1 = (wxWindow *) NULL ;
23511 bool arg2 = (bool) false ;
23512 bool result;
23513 PyObject * obj0 = 0 ;
23514 PyObject * obj1 = 0 ;
23515 char *kwnames[] = {
23516 (char *) "win",(char *) "onlyIfNeeded", NULL
23517 };
23518
23519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23520 if (obj0) {
23521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23522 if (SWIG_arg_fail(1)) SWIG_fail;
23523 }
23524 if (obj1) {
23525 {
23526 arg2 = (bool)(SWIG_As_bool(obj1));
23527 if (SWIG_arg_fail(2)) SWIG_fail;
23528 }
23529 }
23530 {
23531 PyThreadState* __tstate = wxPyBeginAllowThreads();
23532 result = (bool)wxSafeYield(arg1,arg2);
23533
23534 wxPyEndAllowThreads(__tstate);
23535 if (PyErr_Occurred()) SWIG_fail;
23536 }
23537 {
23538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23539 }
23540 return resultobj;
23541 fail:
23542 return NULL;
23543 }
23544
23545
23546 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj;
23548 char *kwnames[] = {
23549 NULL
23550 };
23551
23552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 wxWakeUpIdle();
23556
23557 wxPyEndAllowThreads(__tstate);
23558 if (PyErr_Occurred()) SWIG_fail;
23559 }
23560 Py_INCREF(Py_None); resultobj = Py_None;
23561 return resultobj;
23562 fail:
23563 return NULL;
23564 }
23565
23566
23567 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23568 PyObject *resultobj;
23569 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23570 wxEvent *arg2 = 0 ;
23571 PyObject * obj0 = 0 ;
23572 PyObject * obj1 = 0 ;
23573 char *kwnames[] = {
23574 (char *) "dest",(char *) "event", NULL
23575 };
23576
23577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23579 if (SWIG_arg_fail(1)) SWIG_fail;
23580 {
23581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23582 if (SWIG_arg_fail(2)) SWIG_fail;
23583 if (arg2 == NULL) {
23584 SWIG_null_ref("wxEvent");
23585 }
23586 if (SWIG_arg_fail(2)) SWIG_fail;
23587 }
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 wxPostEvent(arg1,*arg2);
23591
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 Py_INCREF(Py_None); resultobj = Py_None;
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23603 PyObject *resultobj;
23604 char *kwnames[] = {
23605 NULL
23606 };
23607
23608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23609 {
23610 PyThreadState* __tstate = wxPyBeginAllowThreads();
23611 wxApp_CleanUp();
23612
23613 wxPyEndAllowThreads(__tstate);
23614 if (PyErr_Occurred()) SWIG_fail;
23615 }
23616 Py_INCREF(Py_None); resultobj = Py_None;
23617 return resultobj;
23618 fail:
23619 return NULL;
23620 }
23621
23622
23623 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23624 PyObject *resultobj;
23625 wxPyApp *result;
23626 char *kwnames[] = {
23627 NULL
23628 };
23629
23630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23631 {
23632 PyThreadState* __tstate = wxPyBeginAllowThreads();
23633 result = (wxPyApp *)wxPyGetApp();
23634
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 {
23639 resultobj = wxPyMake_wxObject(result, 0);
23640 }
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23648 PyObject *resultobj;
23649 char *arg1 = (char *) 0 ;
23650 PyObject * obj0 = 0 ;
23651 char *kwnames[] = {
23652 (char *) "encoding", NULL
23653 };
23654
23655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23656 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23657 SWIG_arg_fail(1);SWIG_fail;
23658 }
23659 {
23660 PyThreadState* __tstate = wxPyBeginAllowThreads();
23661 wxSetDefaultPyEncoding((char const *)arg1);
23662
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 Py_INCREF(Py_None); resultobj = Py_None;
23667 return resultobj;
23668 fail:
23669 return NULL;
23670 }
23671
23672
23673 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23674 PyObject *resultobj;
23675 char *result;
23676 char *kwnames[] = {
23677 NULL
23678 };
23679
23680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (char *)wxGetDefaultPyEncoding();
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 resultobj = SWIG_FromCharPtr(result);
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23696 PyObject *resultobj;
23697 wxEventLoop *result;
23698 char *kwnames[] = {
23699 NULL
23700 };
23701
23702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23703 {
23704 PyThreadState* __tstate = wxPyBeginAllowThreads();
23705 result = (wxEventLoop *)new wxEventLoop();
23706
23707 wxPyEndAllowThreads(__tstate);
23708 if (PyErr_Occurred()) SWIG_fail;
23709 }
23710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23711 return resultobj;
23712 fail:
23713 return NULL;
23714 }
23715
23716
23717 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23718 PyObject *resultobj;
23719 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23720 PyObject * obj0 = 0 ;
23721 char *kwnames[] = {
23722 (char *) "self", NULL
23723 };
23724
23725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23727 if (SWIG_arg_fail(1)) SWIG_fail;
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 delete arg1;
23731
23732 wxPyEndAllowThreads(__tstate);
23733 if (PyErr_Occurred()) SWIG_fail;
23734 }
23735 Py_INCREF(Py_None); resultobj = Py_None;
23736 return resultobj;
23737 fail:
23738 return NULL;
23739 }
23740
23741
23742 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23743 PyObject *resultobj;
23744 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23745 int result;
23746 PyObject * obj0 = 0 ;
23747 char *kwnames[] = {
23748 (char *) "self", NULL
23749 };
23750
23751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23753 if (SWIG_arg_fail(1)) SWIG_fail;
23754 {
23755 PyThreadState* __tstate = wxPyBeginAllowThreads();
23756 result = (int)(arg1)->Run();
23757
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 {
23762 resultobj = SWIG_From_int((int)(result));
23763 }
23764 return resultobj;
23765 fail:
23766 return NULL;
23767 }
23768
23769
23770 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj;
23772 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23773 int arg2 = (int) 0 ;
23774 PyObject * obj0 = 0 ;
23775 PyObject * obj1 = 0 ;
23776 char *kwnames[] = {
23777 (char *) "self",(char *) "rc", NULL
23778 };
23779
23780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23782 if (SWIG_arg_fail(1)) SWIG_fail;
23783 if (obj1) {
23784 {
23785 arg2 = (int)(SWIG_As_int(obj1));
23786 if (SWIG_arg_fail(2)) SWIG_fail;
23787 }
23788 }
23789 {
23790 PyThreadState* __tstate = wxPyBeginAllowThreads();
23791 (arg1)->Exit(arg2);
23792
23793 wxPyEndAllowThreads(__tstate);
23794 if (PyErr_Occurred()) SWIG_fail;
23795 }
23796 Py_INCREF(Py_None); resultobj = Py_None;
23797 return resultobj;
23798 fail:
23799 return NULL;
23800 }
23801
23802
23803 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23804 PyObject *resultobj;
23805 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23806 bool result;
23807 PyObject * obj0 = 0 ;
23808 char *kwnames[] = {
23809 (char *) "self", NULL
23810 };
23811
23812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23814 if (SWIG_arg_fail(1)) SWIG_fail;
23815 {
23816 PyThreadState* __tstate = wxPyBeginAllowThreads();
23817 result = (bool)((wxEventLoop const *)arg1)->Pending();
23818
23819 wxPyEndAllowThreads(__tstate);
23820 if (PyErr_Occurred()) SWIG_fail;
23821 }
23822 {
23823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23824 }
23825 return resultobj;
23826 fail:
23827 return NULL;
23828 }
23829
23830
23831 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23832 PyObject *resultobj;
23833 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23834 bool result;
23835 PyObject * obj0 = 0 ;
23836 char *kwnames[] = {
23837 (char *) "self", NULL
23838 };
23839
23840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23842 if (SWIG_arg_fail(1)) SWIG_fail;
23843 {
23844 PyThreadState* __tstate = wxPyBeginAllowThreads();
23845 result = (bool)(arg1)->Dispatch();
23846
23847 wxPyEndAllowThreads(__tstate);
23848 if (PyErr_Occurred()) SWIG_fail;
23849 }
23850 {
23851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23852 }
23853 return resultobj;
23854 fail:
23855 return NULL;
23856 }
23857
23858
23859 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23860 PyObject *resultobj;
23861 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23862 bool result;
23863 PyObject * obj0 = 0 ;
23864 char *kwnames[] = {
23865 (char *) "self", NULL
23866 };
23867
23868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23870 if (SWIG_arg_fail(1)) SWIG_fail;
23871 {
23872 PyThreadState* __tstate = wxPyBeginAllowThreads();
23873 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23874
23875 wxPyEndAllowThreads(__tstate);
23876 if (PyErr_Occurred()) SWIG_fail;
23877 }
23878 {
23879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23880 }
23881 return resultobj;
23882 fail:
23883 return NULL;
23884 }
23885
23886
23887 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23888 PyObject *resultobj;
23889 wxEventLoop *result;
23890 char *kwnames[] = {
23891 NULL
23892 };
23893
23894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 result = (wxEventLoop *)wxEventLoop::GetActive();
23898
23899 wxPyEndAllowThreads(__tstate);
23900 if (PyErr_Occurred()) SWIG_fail;
23901 }
23902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23903 return resultobj;
23904 fail:
23905 return NULL;
23906 }
23907
23908
23909 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23910 PyObject *resultobj;
23911 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23912 PyObject * obj0 = 0 ;
23913 char *kwnames[] = {
23914 (char *) "loop", NULL
23915 };
23916
23917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23919 if (SWIG_arg_fail(1)) SWIG_fail;
23920 {
23921 PyThreadState* __tstate = wxPyBeginAllowThreads();
23922 wxEventLoop::SetActive(arg1);
23923
23924 wxPyEndAllowThreads(__tstate);
23925 if (PyErr_Occurred()) SWIG_fail;
23926 }
23927 Py_INCREF(Py_None); resultobj = Py_None;
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23935 PyObject *obj;
23936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23937 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23938 Py_INCREF(obj);
23939 return Py_BuildValue((char *)"");
23940 }
23941 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23942 PyObject *resultobj;
23943 int arg1 = (int) 0 ;
23944 int arg2 = (int) 0 ;
23945 int arg3 = (int) 0 ;
23946 wxAcceleratorEntry *result;
23947 PyObject * obj0 = 0 ;
23948 PyObject * obj1 = 0 ;
23949 PyObject * obj2 = 0 ;
23950 char *kwnames[] = {
23951 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23952 };
23953
23954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23955 if (obj0) {
23956 {
23957 arg1 = (int)(SWIG_As_int(obj0));
23958 if (SWIG_arg_fail(1)) SWIG_fail;
23959 }
23960 }
23961 if (obj1) {
23962 {
23963 arg2 = (int)(SWIG_As_int(obj1));
23964 if (SWIG_arg_fail(2)) SWIG_fail;
23965 }
23966 }
23967 if (obj2) {
23968 {
23969 arg3 = (int)(SWIG_As_int(obj2));
23970 if (SWIG_arg_fail(3)) SWIG_fail;
23971 }
23972 }
23973 {
23974 PyThreadState* __tstate = wxPyBeginAllowThreads();
23975 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23976
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23981 return resultobj;
23982 fail:
23983 return NULL;
23984 }
23985
23986
23987 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23988 PyObject *resultobj;
23989 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23990 PyObject * obj0 = 0 ;
23991 char *kwnames[] = {
23992 (char *) "self", NULL
23993 };
23994
23995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23997 if (SWIG_arg_fail(1)) SWIG_fail;
23998 {
23999 PyThreadState* __tstate = wxPyBeginAllowThreads();
24000 delete arg1;
24001
24002 wxPyEndAllowThreads(__tstate);
24003 if (PyErr_Occurred()) SWIG_fail;
24004 }
24005 Py_INCREF(Py_None); resultobj = Py_None;
24006 return resultobj;
24007 fail:
24008 return NULL;
24009 }
24010
24011
24012 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24013 PyObject *resultobj;
24014 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24015 int arg2 ;
24016 int arg3 ;
24017 int arg4 ;
24018 PyObject * obj0 = 0 ;
24019 PyObject * obj1 = 0 ;
24020 PyObject * obj2 = 0 ;
24021 PyObject * obj3 = 0 ;
24022 char *kwnames[] = {
24023 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24024 };
24025
24026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24028 if (SWIG_arg_fail(1)) SWIG_fail;
24029 {
24030 arg2 = (int)(SWIG_As_int(obj1));
24031 if (SWIG_arg_fail(2)) SWIG_fail;
24032 }
24033 {
24034 arg3 = (int)(SWIG_As_int(obj2));
24035 if (SWIG_arg_fail(3)) SWIG_fail;
24036 }
24037 {
24038 arg4 = (int)(SWIG_As_int(obj3));
24039 if (SWIG_arg_fail(4)) SWIG_fail;
24040 }
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 (arg1)->Set(arg2,arg3,arg4);
24044
24045 wxPyEndAllowThreads(__tstate);
24046 if (PyErr_Occurred()) SWIG_fail;
24047 }
24048 Py_INCREF(Py_None); resultobj = Py_None;
24049 return resultobj;
24050 fail:
24051 return NULL;
24052 }
24053
24054
24055 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24056 PyObject *resultobj;
24057 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24058 int result;
24059 PyObject * obj0 = 0 ;
24060 char *kwnames[] = {
24061 (char *) "self", NULL
24062 };
24063
24064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24066 if (SWIG_arg_fail(1)) SWIG_fail;
24067 {
24068 PyThreadState* __tstate = wxPyBeginAllowThreads();
24069 result = (int)(arg1)->GetFlags();
24070
24071 wxPyEndAllowThreads(__tstate);
24072 if (PyErr_Occurred()) SWIG_fail;
24073 }
24074 {
24075 resultobj = SWIG_From_int((int)(result));
24076 }
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24084 PyObject *resultobj;
24085 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24086 int result;
24087 PyObject * obj0 = 0 ;
24088 char *kwnames[] = {
24089 (char *) "self", NULL
24090 };
24091
24092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24094 if (SWIG_arg_fail(1)) SWIG_fail;
24095 {
24096 PyThreadState* __tstate = wxPyBeginAllowThreads();
24097 result = (int)(arg1)->GetKeyCode();
24098
24099 wxPyEndAllowThreads(__tstate);
24100 if (PyErr_Occurred()) SWIG_fail;
24101 }
24102 {
24103 resultobj = SWIG_From_int((int)(result));
24104 }
24105 return resultobj;
24106 fail:
24107 return NULL;
24108 }
24109
24110
24111 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24112 PyObject *resultobj;
24113 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24114 int result;
24115 PyObject * obj0 = 0 ;
24116 char *kwnames[] = {
24117 (char *) "self", NULL
24118 };
24119
24120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24122 if (SWIG_arg_fail(1)) SWIG_fail;
24123 {
24124 PyThreadState* __tstate = wxPyBeginAllowThreads();
24125 result = (int)(arg1)->GetCommand();
24126
24127 wxPyEndAllowThreads(__tstate);
24128 if (PyErr_Occurred()) SWIG_fail;
24129 }
24130 {
24131 resultobj = SWIG_From_int((int)(result));
24132 }
24133 return resultobj;
24134 fail:
24135 return NULL;
24136 }
24137
24138
24139 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24140 PyObject *obj;
24141 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24142 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24143 Py_INCREF(obj);
24144 return Py_BuildValue((char *)"");
24145 }
24146 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24147 PyObject *resultobj;
24148 int arg1 ;
24149 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24150 wxAcceleratorTable *result;
24151 PyObject * obj0 = 0 ;
24152 char *kwnames[] = {
24153 (char *) "n", NULL
24154 };
24155
24156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24157 {
24158 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24159 if (arg2) arg1 = PyList_Size(obj0);
24160 else arg1 = 0;
24161 }
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24165
24166 wxPyEndAllowThreads(__tstate);
24167 if (PyErr_Occurred()) SWIG_fail;
24168 }
24169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24170 {
24171 delete [] arg2;
24172 }
24173 return resultobj;
24174 fail:
24175 {
24176 delete [] arg2;
24177 }
24178 return NULL;
24179 }
24180
24181
24182 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24183 PyObject *resultobj;
24184 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24185 PyObject * obj0 = 0 ;
24186 char *kwnames[] = {
24187 (char *) "self", NULL
24188 };
24189
24190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24192 if (SWIG_arg_fail(1)) SWIG_fail;
24193 {
24194 PyThreadState* __tstate = wxPyBeginAllowThreads();
24195 delete arg1;
24196
24197 wxPyEndAllowThreads(__tstate);
24198 if (PyErr_Occurred()) SWIG_fail;
24199 }
24200 Py_INCREF(Py_None); resultobj = Py_None;
24201 return resultobj;
24202 fail:
24203 return NULL;
24204 }
24205
24206
24207 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24208 PyObject *resultobj;
24209 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24210 bool result;
24211 PyObject * obj0 = 0 ;
24212 char *kwnames[] = {
24213 (char *) "self", NULL
24214 };
24215
24216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24218 if (SWIG_arg_fail(1)) SWIG_fail;
24219 {
24220 PyThreadState* __tstate = wxPyBeginAllowThreads();
24221 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24222
24223 wxPyEndAllowThreads(__tstate);
24224 if (PyErr_Occurred()) SWIG_fail;
24225 }
24226 {
24227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24228 }
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24236 PyObject *obj;
24237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24238 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24239 Py_INCREF(obj);
24240 return Py_BuildValue((char *)"");
24241 }
24242 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24243 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24244 return 1;
24245 }
24246
24247
24248 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24249 PyObject *pyobj;
24250
24251 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24252 return pyobj;
24253 }
24254
24255
24256 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24257 PyObject *resultobj;
24258 wxString *arg1 = 0 ;
24259 wxAcceleratorEntry *result;
24260 bool temp1 = false ;
24261 PyObject * obj0 = 0 ;
24262 char *kwnames[] = {
24263 (char *) "label", NULL
24264 };
24265
24266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24267 {
24268 arg1 = wxString_in_helper(obj0);
24269 if (arg1 == NULL) SWIG_fail;
24270 temp1 = true;
24271 }
24272 {
24273 PyThreadState* __tstate = wxPyBeginAllowThreads();
24274 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24275
24276 wxPyEndAllowThreads(__tstate);
24277 if (PyErr_Occurred()) SWIG_fail;
24278 }
24279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24280 {
24281 if (temp1)
24282 delete arg1;
24283 }
24284 return resultobj;
24285 fail:
24286 {
24287 if (temp1)
24288 delete arg1;
24289 }
24290 return NULL;
24291 }
24292
24293
24294 static int _wrap_PanelNameStr_set(PyObject *) {
24295 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24296 return 1;
24297 }
24298
24299
24300 static PyObject *_wrap_PanelNameStr_get(void) {
24301 PyObject *pyobj;
24302
24303 {
24304 #if wxUSE_UNICODE
24305 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24306 #else
24307 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24308 #endif
24309 }
24310 return pyobj;
24311 }
24312
24313
24314 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24315 PyObject *resultobj;
24316 wxVisualAttributes *result;
24317 char *kwnames[] = {
24318 NULL
24319 };
24320
24321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 result = (wxVisualAttributes *)new_wxVisualAttributes();
24325
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24330 return resultobj;
24331 fail:
24332 return NULL;
24333 }
24334
24335
24336 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24337 PyObject *resultobj;
24338 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24339 PyObject * obj0 = 0 ;
24340 char *kwnames[] = {
24341 (char *) "self", NULL
24342 };
24343
24344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 delete_wxVisualAttributes(arg1);
24350
24351 wxPyEndAllowThreads(__tstate);
24352 if (PyErr_Occurred()) SWIG_fail;
24353 }
24354 Py_INCREF(Py_None); resultobj = Py_None;
24355 return resultobj;
24356 fail:
24357 return NULL;
24358 }
24359
24360
24361 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24362 PyObject *resultobj;
24363 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24364 wxFont *arg2 = (wxFont *) 0 ;
24365 PyObject * obj0 = 0 ;
24366 PyObject * obj1 = 0 ;
24367 char *kwnames[] = {
24368 (char *) "self",(char *) "font", NULL
24369 };
24370
24371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24373 if (SWIG_arg_fail(1)) SWIG_fail;
24374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24375 if (SWIG_arg_fail(2)) SWIG_fail;
24376 if (arg1) (arg1)->font = *arg2;
24377
24378 Py_INCREF(Py_None); resultobj = Py_None;
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24386 PyObject *resultobj;
24387 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24388 wxFont *result;
24389 PyObject * obj0 = 0 ;
24390 char *kwnames[] = {
24391 (char *) "self", NULL
24392 };
24393
24394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24396 if (SWIG_arg_fail(1)) SWIG_fail;
24397 result = (wxFont *)& ((arg1)->font);
24398
24399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24400 return resultobj;
24401 fail:
24402 return NULL;
24403 }
24404
24405
24406 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj;
24408 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24409 wxColour *arg2 = (wxColour *) 0 ;
24410 PyObject * obj0 = 0 ;
24411 PyObject * obj1 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self",(char *) "colFg", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24420 if (SWIG_arg_fail(2)) SWIG_fail;
24421 if (arg1) (arg1)->colFg = *arg2;
24422
24423 Py_INCREF(Py_None); resultobj = Py_None;
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj;
24432 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24433 wxColour *result;
24434 PyObject * obj0 = 0 ;
24435 char *kwnames[] = {
24436 (char *) "self", NULL
24437 };
24438
24439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24441 if (SWIG_arg_fail(1)) SWIG_fail;
24442 result = (wxColour *)& ((arg1)->colFg);
24443
24444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24445 return resultobj;
24446 fail:
24447 return NULL;
24448 }
24449
24450
24451 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24452 PyObject *resultobj;
24453 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24454 wxColour *arg2 = (wxColour *) 0 ;
24455 PyObject * obj0 = 0 ;
24456 PyObject * obj1 = 0 ;
24457 char *kwnames[] = {
24458 (char *) "self",(char *) "colBg", NULL
24459 };
24460
24461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24463 if (SWIG_arg_fail(1)) SWIG_fail;
24464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24465 if (SWIG_arg_fail(2)) SWIG_fail;
24466 if (arg1) (arg1)->colBg = *arg2;
24467
24468 Py_INCREF(Py_None); resultobj = Py_None;
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24476 PyObject *resultobj;
24477 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24478 wxColour *result;
24479 PyObject * obj0 = 0 ;
24480 char *kwnames[] = {
24481 (char *) "self", NULL
24482 };
24483
24484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24486 if (SWIG_arg_fail(1)) SWIG_fail;
24487 result = (wxColour *)& ((arg1)->colBg);
24488
24489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24490 return resultobj;
24491 fail:
24492 return NULL;
24493 }
24494
24495
24496 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24497 PyObject *obj;
24498 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24499 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24500 Py_INCREF(obj);
24501 return Py_BuildValue((char *)"");
24502 }
24503 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24504 PyObject *resultobj;
24505 wxWindow *arg1 = (wxWindow *) 0 ;
24506 int arg2 = (int) (int)-1 ;
24507 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24508 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24509 wxSize const &arg4_defvalue = wxDefaultSize ;
24510 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24511 long arg5 = (long) 0 ;
24512 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24513 wxString *arg6 = (wxString *) &arg6_defvalue ;
24514 wxWindow *result;
24515 wxPoint temp3 ;
24516 wxSize temp4 ;
24517 bool temp6 = false ;
24518 PyObject * obj0 = 0 ;
24519 PyObject * obj1 = 0 ;
24520 PyObject * obj2 = 0 ;
24521 PyObject * obj3 = 0 ;
24522 PyObject * obj4 = 0 ;
24523 PyObject * obj5 = 0 ;
24524 char *kwnames[] = {
24525 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24526 };
24527
24528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24530 if (SWIG_arg_fail(1)) SWIG_fail;
24531 if (obj1) {
24532 {
24533 arg2 = (int const)(SWIG_As_int(obj1));
24534 if (SWIG_arg_fail(2)) SWIG_fail;
24535 }
24536 }
24537 if (obj2) {
24538 {
24539 arg3 = &temp3;
24540 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24541 }
24542 }
24543 if (obj3) {
24544 {
24545 arg4 = &temp4;
24546 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24547 }
24548 }
24549 if (obj4) {
24550 {
24551 arg5 = (long)(SWIG_As_long(obj4));
24552 if (SWIG_arg_fail(5)) SWIG_fail;
24553 }
24554 }
24555 if (obj5) {
24556 {
24557 arg6 = wxString_in_helper(obj5);
24558 if (arg6 == NULL) SWIG_fail;
24559 temp6 = true;
24560 }
24561 }
24562 {
24563 if (!wxPyCheckForApp()) SWIG_fail;
24564 PyThreadState* __tstate = wxPyBeginAllowThreads();
24565 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24566
24567 wxPyEndAllowThreads(__tstate);
24568 if (PyErr_Occurred()) SWIG_fail;
24569 }
24570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24571 {
24572 if (temp6)
24573 delete arg6;
24574 }
24575 return resultobj;
24576 fail:
24577 {
24578 if (temp6)
24579 delete arg6;
24580 }
24581 return NULL;
24582 }
24583
24584
24585 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24586 PyObject *resultobj;
24587 wxWindow *result;
24588 char *kwnames[] = {
24589 NULL
24590 };
24591
24592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24593 {
24594 if (!wxPyCheckForApp()) SWIG_fail;
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 result = (wxWindow *)new wxWindow();
24597
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24609 PyObject *resultobj;
24610 wxWindow *arg1 = (wxWindow *) 0 ;
24611 wxWindow *arg2 = (wxWindow *) 0 ;
24612 int arg3 = (int) (int)-1 ;
24613 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24614 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24615 wxSize const &arg5_defvalue = wxDefaultSize ;
24616 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24617 long arg6 = (long) 0 ;
24618 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24619 wxString *arg7 = (wxString *) &arg7_defvalue ;
24620 bool result;
24621 wxPoint temp4 ;
24622 wxSize temp5 ;
24623 bool temp7 = false ;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 PyObject * obj2 = 0 ;
24627 PyObject * obj3 = 0 ;
24628 PyObject * obj4 = 0 ;
24629 PyObject * obj5 = 0 ;
24630 PyObject * obj6 = 0 ;
24631 char *kwnames[] = {
24632 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24633 };
24634
24635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24637 if (SWIG_arg_fail(1)) SWIG_fail;
24638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24639 if (SWIG_arg_fail(2)) SWIG_fail;
24640 if (obj2) {
24641 {
24642 arg3 = (int const)(SWIG_As_int(obj2));
24643 if (SWIG_arg_fail(3)) SWIG_fail;
24644 }
24645 }
24646 if (obj3) {
24647 {
24648 arg4 = &temp4;
24649 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24650 }
24651 }
24652 if (obj4) {
24653 {
24654 arg5 = &temp5;
24655 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24656 }
24657 }
24658 if (obj5) {
24659 {
24660 arg6 = (long)(SWIG_As_long(obj5));
24661 if (SWIG_arg_fail(6)) SWIG_fail;
24662 }
24663 }
24664 if (obj6) {
24665 {
24666 arg7 = wxString_in_helper(obj6);
24667 if (arg7 == NULL) SWIG_fail;
24668 temp7 = true;
24669 }
24670 }
24671 {
24672 PyThreadState* __tstate = wxPyBeginAllowThreads();
24673 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24674
24675 wxPyEndAllowThreads(__tstate);
24676 if (PyErr_Occurred()) SWIG_fail;
24677 }
24678 {
24679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24680 }
24681 {
24682 if (temp7)
24683 delete arg7;
24684 }
24685 return resultobj;
24686 fail:
24687 {
24688 if (temp7)
24689 delete arg7;
24690 }
24691 return NULL;
24692 }
24693
24694
24695 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24696 PyObject *resultobj;
24697 wxWindow *arg1 = (wxWindow *) 0 ;
24698 bool arg2 = (bool) false ;
24699 bool result;
24700 PyObject * obj0 = 0 ;
24701 PyObject * obj1 = 0 ;
24702 char *kwnames[] = {
24703 (char *) "self",(char *) "force", NULL
24704 };
24705
24706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24708 if (SWIG_arg_fail(1)) SWIG_fail;
24709 if (obj1) {
24710 {
24711 arg2 = (bool)(SWIG_As_bool(obj1));
24712 if (SWIG_arg_fail(2)) SWIG_fail;
24713 }
24714 }
24715 {
24716 PyThreadState* __tstate = wxPyBeginAllowThreads();
24717 result = (bool)(arg1)->Close(arg2);
24718
24719 wxPyEndAllowThreads(__tstate);
24720 if (PyErr_Occurred()) SWIG_fail;
24721 }
24722 {
24723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24724 }
24725 return resultobj;
24726 fail:
24727 return NULL;
24728 }
24729
24730
24731 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24732 PyObject *resultobj;
24733 wxWindow *arg1 = (wxWindow *) 0 ;
24734 bool result;
24735 PyObject * obj0 = 0 ;
24736 char *kwnames[] = {
24737 (char *) "self", NULL
24738 };
24739
24740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24742 if (SWIG_arg_fail(1)) SWIG_fail;
24743 {
24744 PyThreadState* __tstate = wxPyBeginAllowThreads();
24745 result = (bool)(arg1)->Destroy();
24746
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 {
24751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24752 }
24753 return resultobj;
24754 fail:
24755 return NULL;
24756 }
24757
24758
24759 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24760 PyObject *resultobj;
24761 wxWindow *arg1 = (wxWindow *) 0 ;
24762 bool result;
24763 PyObject * obj0 = 0 ;
24764 char *kwnames[] = {
24765 (char *) "self", NULL
24766 };
24767
24768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24770 if (SWIG_arg_fail(1)) SWIG_fail;
24771 {
24772 PyThreadState* __tstate = wxPyBeginAllowThreads();
24773 result = (bool)(arg1)->DestroyChildren();
24774
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 {
24779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24780 }
24781 return resultobj;
24782 fail:
24783 return NULL;
24784 }
24785
24786
24787 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24788 PyObject *resultobj;
24789 wxWindow *arg1 = (wxWindow *) 0 ;
24790 bool result;
24791 PyObject * obj0 = 0 ;
24792 char *kwnames[] = {
24793 (char *) "self", NULL
24794 };
24795
24796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24798 if (SWIG_arg_fail(1)) SWIG_fail;
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24802
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 {
24807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24808 }
24809 return resultobj;
24810 fail:
24811 return NULL;
24812 }
24813
24814
24815 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24816 PyObject *resultobj;
24817 wxWindow *arg1 = (wxWindow *) 0 ;
24818 wxString *arg2 = 0 ;
24819 bool temp2 = false ;
24820 PyObject * obj0 = 0 ;
24821 PyObject * obj1 = 0 ;
24822 char *kwnames[] = {
24823 (char *) "self",(char *) "title", NULL
24824 };
24825
24826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24828 if (SWIG_arg_fail(1)) SWIG_fail;
24829 {
24830 arg2 = wxString_in_helper(obj1);
24831 if (arg2 == NULL) SWIG_fail;
24832 temp2 = true;
24833 }
24834 {
24835 PyThreadState* __tstate = wxPyBeginAllowThreads();
24836 (arg1)->SetTitle((wxString const &)*arg2);
24837
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 Py_INCREF(Py_None); resultobj = Py_None;
24842 {
24843 if (temp2)
24844 delete arg2;
24845 }
24846 return resultobj;
24847 fail:
24848 {
24849 if (temp2)
24850 delete arg2;
24851 }
24852 return NULL;
24853 }
24854
24855
24856 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24857 PyObject *resultobj;
24858 wxWindow *arg1 = (wxWindow *) 0 ;
24859 wxString result;
24860 PyObject * obj0 = 0 ;
24861 char *kwnames[] = {
24862 (char *) "self", NULL
24863 };
24864
24865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24867 if (SWIG_arg_fail(1)) SWIG_fail;
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 result = ((wxWindow const *)arg1)->GetTitle();
24871
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 {
24876 #if wxUSE_UNICODE
24877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24878 #else
24879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24880 #endif
24881 }
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24889 PyObject *resultobj;
24890 wxWindow *arg1 = (wxWindow *) 0 ;
24891 wxString *arg2 = 0 ;
24892 bool temp2 = false ;
24893 PyObject * obj0 = 0 ;
24894 PyObject * obj1 = 0 ;
24895 char *kwnames[] = {
24896 (char *) "self",(char *) "label", NULL
24897 };
24898
24899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24901 if (SWIG_arg_fail(1)) SWIG_fail;
24902 {
24903 arg2 = wxString_in_helper(obj1);
24904 if (arg2 == NULL) SWIG_fail;
24905 temp2 = true;
24906 }
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 (arg1)->SetLabel((wxString const &)*arg2);
24910
24911 wxPyEndAllowThreads(__tstate);
24912 if (PyErr_Occurred()) SWIG_fail;
24913 }
24914 Py_INCREF(Py_None); resultobj = Py_None;
24915 {
24916 if (temp2)
24917 delete arg2;
24918 }
24919 return resultobj;
24920 fail:
24921 {
24922 if (temp2)
24923 delete arg2;
24924 }
24925 return NULL;
24926 }
24927
24928
24929 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj;
24931 wxWindow *arg1 = (wxWindow *) 0 ;
24932 wxString result;
24933 PyObject * obj0 = 0 ;
24934 char *kwnames[] = {
24935 (char *) "self", NULL
24936 };
24937
24938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24940 if (SWIG_arg_fail(1)) SWIG_fail;
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = ((wxWindow const *)arg1)->GetLabel();
24944
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 {
24949 #if wxUSE_UNICODE
24950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24951 #else
24952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24953 #endif
24954 }
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24962 PyObject *resultobj;
24963 wxWindow *arg1 = (wxWindow *) 0 ;
24964 wxString *arg2 = 0 ;
24965 bool temp2 = false ;
24966 PyObject * obj0 = 0 ;
24967 PyObject * obj1 = 0 ;
24968 char *kwnames[] = {
24969 (char *) "self",(char *) "name", NULL
24970 };
24971
24972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24974 if (SWIG_arg_fail(1)) SWIG_fail;
24975 {
24976 arg2 = wxString_in_helper(obj1);
24977 if (arg2 == NULL) SWIG_fail;
24978 temp2 = true;
24979 }
24980 {
24981 PyThreadState* __tstate = wxPyBeginAllowThreads();
24982 (arg1)->SetName((wxString const &)*arg2);
24983
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 Py_INCREF(Py_None); resultobj = Py_None;
24988 {
24989 if (temp2)
24990 delete arg2;
24991 }
24992 return resultobj;
24993 fail:
24994 {
24995 if (temp2)
24996 delete arg2;
24997 }
24998 return NULL;
24999 }
25000
25001
25002 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25003 PyObject *resultobj;
25004 wxWindow *arg1 = (wxWindow *) 0 ;
25005 wxString result;
25006 PyObject * obj0 = 0 ;
25007 char *kwnames[] = {
25008 (char *) "self", NULL
25009 };
25010
25011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25013 if (SWIG_arg_fail(1)) SWIG_fail;
25014 {
25015 PyThreadState* __tstate = wxPyBeginAllowThreads();
25016 result = ((wxWindow const *)arg1)->GetName();
25017
25018 wxPyEndAllowThreads(__tstate);
25019 if (PyErr_Occurred()) SWIG_fail;
25020 }
25021 {
25022 #if wxUSE_UNICODE
25023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25024 #else
25025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25026 #endif
25027 }
25028 return resultobj;
25029 fail:
25030 return NULL;
25031 }
25032
25033
25034 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25035 PyObject *resultobj;
25036 wxWindow *arg1 = (wxWindow *) 0 ;
25037 wxWindowVariant arg2 ;
25038 PyObject * obj0 = 0 ;
25039 PyObject * obj1 = 0 ;
25040 char *kwnames[] = {
25041 (char *) "self",(char *) "variant", NULL
25042 };
25043
25044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25046 if (SWIG_arg_fail(1)) SWIG_fail;
25047 {
25048 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25049 if (SWIG_arg_fail(2)) SWIG_fail;
25050 }
25051 {
25052 PyThreadState* __tstate = wxPyBeginAllowThreads();
25053 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25054
25055 wxPyEndAllowThreads(__tstate);
25056 if (PyErr_Occurred()) SWIG_fail;
25057 }
25058 Py_INCREF(Py_None); resultobj = Py_None;
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj;
25067 wxWindow *arg1 = (wxWindow *) 0 ;
25068 wxWindowVariant result;
25069 PyObject * obj0 = 0 ;
25070 char *kwnames[] = {
25071 (char *) "self", NULL
25072 };
25073
25074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25076 if (SWIG_arg_fail(1)) SWIG_fail;
25077 {
25078 PyThreadState* __tstate = wxPyBeginAllowThreads();
25079 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25080
25081 wxPyEndAllowThreads(__tstate);
25082 if (PyErr_Occurred()) SWIG_fail;
25083 }
25084 resultobj = SWIG_From_int((result));
25085 return resultobj;
25086 fail:
25087 return NULL;
25088 }
25089
25090
25091 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25092 PyObject *resultobj;
25093 wxWindow *arg1 = (wxWindow *) 0 ;
25094 int arg2 ;
25095 PyObject * obj0 = 0 ;
25096 PyObject * obj1 = 0 ;
25097 char *kwnames[] = {
25098 (char *) "self",(char *) "winid", NULL
25099 };
25100
25101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25103 if (SWIG_arg_fail(1)) SWIG_fail;
25104 {
25105 arg2 = (int)(SWIG_As_int(obj1));
25106 if (SWIG_arg_fail(2)) SWIG_fail;
25107 }
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 (arg1)->SetId(arg2);
25111
25112 wxPyEndAllowThreads(__tstate);
25113 if (PyErr_Occurred()) SWIG_fail;
25114 }
25115 Py_INCREF(Py_None); resultobj = Py_None;
25116 return resultobj;
25117 fail:
25118 return NULL;
25119 }
25120
25121
25122 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25123 PyObject *resultobj;
25124 wxWindow *arg1 = (wxWindow *) 0 ;
25125 int result;
25126 PyObject * obj0 = 0 ;
25127 char *kwnames[] = {
25128 (char *) "self", NULL
25129 };
25130
25131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25133 if (SWIG_arg_fail(1)) SWIG_fail;
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 result = (int)((wxWindow const *)arg1)->GetId();
25137
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 {
25142 resultobj = SWIG_From_int((int)(result));
25143 }
25144 return resultobj;
25145 fail:
25146 return NULL;
25147 }
25148
25149
25150 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25151 PyObject *resultobj;
25152 int result;
25153 char *kwnames[] = {
25154 NULL
25155 };
25156
25157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25158 {
25159 PyThreadState* __tstate = wxPyBeginAllowThreads();
25160 result = (int)wxWindow::NewControlId();
25161
25162 wxPyEndAllowThreads(__tstate);
25163 if (PyErr_Occurred()) SWIG_fail;
25164 }
25165 {
25166 resultobj = SWIG_From_int((int)(result));
25167 }
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25175 PyObject *resultobj;
25176 int arg1 ;
25177 int result;
25178 PyObject * obj0 = 0 ;
25179 char *kwnames[] = {
25180 (char *) "winid", NULL
25181 };
25182
25183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25184 {
25185 arg1 = (int)(SWIG_As_int(obj0));
25186 if (SWIG_arg_fail(1)) SWIG_fail;
25187 }
25188 {
25189 PyThreadState* __tstate = wxPyBeginAllowThreads();
25190 result = (int)wxWindow::NextControlId(arg1);
25191
25192 wxPyEndAllowThreads(__tstate);
25193 if (PyErr_Occurred()) SWIG_fail;
25194 }
25195 {
25196 resultobj = SWIG_From_int((int)(result));
25197 }
25198 return resultobj;
25199 fail:
25200 return NULL;
25201 }
25202
25203
25204 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25205 PyObject *resultobj;
25206 int arg1 ;
25207 int result;
25208 PyObject * obj0 = 0 ;
25209 char *kwnames[] = {
25210 (char *) "winid", NULL
25211 };
25212
25213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25214 {
25215 arg1 = (int)(SWIG_As_int(obj0));
25216 if (SWIG_arg_fail(1)) SWIG_fail;
25217 }
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 result = (int)wxWindow::PrevControlId(arg1);
25221
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 {
25226 resultobj = SWIG_From_int((int)(result));
25227 }
25228 return resultobj;
25229 fail:
25230 return NULL;
25231 }
25232
25233
25234 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25235 PyObject *resultobj;
25236 wxWindow *arg1 = (wxWindow *) 0 ;
25237 wxSize *arg2 = 0 ;
25238 wxSize temp2 ;
25239 PyObject * obj0 = 0 ;
25240 PyObject * obj1 = 0 ;
25241 char *kwnames[] = {
25242 (char *) "self",(char *) "size", NULL
25243 };
25244
25245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25247 if (SWIG_arg_fail(1)) SWIG_fail;
25248 {
25249 arg2 = &temp2;
25250 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25251 }
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 (arg1)->SetSize((wxSize const &)*arg2);
25255
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 Py_INCREF(Py_None); resultobj = Py_None;
25260 return resultobj;
25261 fail:
25262 return NULL;
25263 }
25264
25265
25266 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj;
25268 wxWindow *arg1 = (wxWindow *) 0 ;
25269 int arg2 ;
25270 int arg3 ;
25271 int arg4 ;
25272 int arg5 ;
25273 int arg6 = (int) wxSIZE_AUTO ;
25274 PyObject * obj0 = 0 ;
25275 PyObject * obj1 = 0 ;
25276 PyObject * obj2 = 0 ;
25277 PyObject * obj3 = 0 ;
25278 PyObject * obj4 = 0 ;
25279 PyObject * obj5 = 0 ;
25280 char *kwnames[] = {
25281 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25282 };
25283
25284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25286 if (SWIG_arg_fail(1)) SWIG_fail;
25287 {
25288 arg2 = (int)(SWIG_As_int(obj1));
25289 if (SWIG_arg_fail(2)) SWIG_fail;
25290 }
25291 {
25292 arg3 = (int)(SWIG_As_int(obj2));
25293 if (SWIG_arg_fail(3)) SWIG_fail;
25294 }
25295 {
25296 arg4 = (int)(SWIG_As_int(obj3));
25297 if (SWIG_arg_fail(4)) SWIG_fail;
25298 }
25299 {
25300 arg5 = (int)(SWIG_As_int(obj4));
25301 if (SWIG_arg_fail(5)) SWIG_fail;
25302 }
25303 if (obj5) {
25304 {
25305 arg6 = (int)(SWIG_As_int(obj5));
25306 if (SWIG_arg_fail(6)) SWIG_fail;
25307 }
25308 }
25309 {
25310 PyThreadState* __tstate = wxPyBeginAllowThreads();
25311 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25312
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 Py_INCREF(Py_None); resultobj = Py_None;
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25324 PyObject *resultobj;
25325 wxWindow *arg1 = (wxWindow *) 0 ;
25326 wxRect *arg2 = 0 ;
25327 int arg3 = (int) wxSIZE_AUTO ;
25328 wxRect temp2 ;
25329 PyObject * obj0 = 0 ;
25330 PyObject * obj1 = 0 ;
25331 PyObject * obj2 = 0 ;
25332 char *kwnames[] = {
25333 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25334 };
25335
25336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25338 if (SWIG_arg_fail(1)) SWIG_fail;
25339 {
25340 arg2 = &temp2;
25341 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25342 }
25343 if (obj2) {
25344 {
25345 arg3 = (int)(SWIG_As_int(obj2));
25346 if (SWIG_arg_fail(3)) SWIG_fail;
25347 }
25348 }
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25352
25353 wxPyEndAllowThreads(__tstate);
25354 if (PyErr_Occurred()) SWIG_fail;
25355 }
25356 Py_INCREF(Py_None); resultobj = Py_None;
25357 return resultobj;
25358 fail:
25359 return NULL;
25360 }
25361
25362
25363 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj;
25365 wxWindow *arg1 = (wxWindow *) 0 ;
25366 int arg2 ;
25367 int arg3 ;
25368 PyObject * obj0 = 0 ;
25369 PyObject * obj1 = 0 ;
25370 PyObject * obj2 = 0 ;
25371 char *kwnames[] = {
25372 (char *) "self",(char *) "width",(char *) "height", NULL
25373 };
25374
25375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25377 if (SWIG_arg_fail(1)) SWIG_fail;
25378 {
25379 arg2 = (int)(SWIG_As_int(obj1));
25380 if (SWIG_arg_fail(2)) SWIG_fail;
25381 }
25382 {
25383 arg3 = (int)(SWIG_As_int(obj2));
25384 if (SWIG_arg_fail(3)) SWIG_fail;
25385 }
25386 {
25387 PyThreadState* __tstate = wxPyBeginAllowThreads();
25388 (arg1)->SetSize(arg2,arg3);
25389
25390 wxPyEndAllowThreads(__tstate);
25391 if (PyErr_Occurred()) SWIG_fail;
25392 }
25393 Py_INCREF(Py_None); resultobj = Py_None;
25394 return resultobj;
25395 fail:
25396 return NULL;
25397 }
25398
25399
25400 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj;
25402 wxWindow *arg1 = (wxWindow *) 0 ;
25403 wxPoint *arg2 = 0 ;
25404 int arg3 = (int) wxSIZE_USE_EXISTING ;
25405 wxPoint temp2 ;
25406 PyObject * obj0 = 0 ;
25407 PyObject * obj1 = 0 ;
25408 PyObject * obj2 = 0 ;
25409 char *kwnames[] = {
25410 (char *) "self",(char *) "pt",(char *) "flags", NULL
25411 };
25412
25413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25415 if (SWIG_arg_fail(1)) SWIG_fail;
25416 {
25417 arg2 = &temp2;
25418 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25419 }
25420 if (obj2) {
25421 {
25422 arg3 = (int)(SWIG_As_int(obj2));
25423 if (SWIG_arg_fail(3)) SWIG_fail;
25424 }
25425 }
25426 {
25427 PyThreadState* __tstate = wxPyBeginAllowThreads();
25428 (arg1)->Move((wxPoint const &)*arg2,arg3);
25429
25430 wxPyEndAllowThreads(__tstate);
25431 if (PyErr_Occurred()) SWIG_fail;
25432 }
25433 Py_INCREF(Py_None); resultobj = Py_None;
25434 return resultobj;
25435 fail:
25436 return NULL;
25437 }
25438
25439
25440 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25441 PyObject *resultobj;
25442 wxWindow *arg1 = (wxWindow *) 0 ;
25443 int arg2 ;
25444 int arg3 ;
25445 int arg4 = (int) wxSIZE_USE_EXISTING ;
25446 PyObject * obj0 = 0 ;
25447 PyObject * obj1 = 0 ;
25448 PyObject * obj2 = 0 ;
25449 PyObject * obj3 = 0 ;
25450 char *kwnames[] = {
25451 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25452 };
25453
25454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25456 if (SWIG_arg_fail(1)) SWIG_fail;
25457 {
25458 arg2 = (int)(SWIG_As_int(obj1));
25459 if (SWIG_arg_fail(2)) SWIG_fail;
25460 }
25461 {
25462 arg3 = (int)(SWIG_As_int(obj2));
25463 if (SWIG_arg_fail(3)) SWIG_fail;
25464 }
25465 if (obj3) {
25466 {
25467 arg4 = (int)(SWIG_As_int(obj3));
25468 if (SWIG_arg_fail(4)) SWIG_fail;
25469 }
25470 }
25471 {
25472 PyThreadState* __tstate = wxPyBeginAllowThreads();
25473 (arg1)->Move(arg2,arg3,arg4);
25474
25475 wxPyEndAllowThreads(__tstate);
25476 if (PyErr_Occurred()) SWIG_fail;
25477 }
25478 Py_INCREF(Py_None); resultobj = Py_None;
25479 return resultobj;
25480 fail:
25481 return NULL;
25482 }
25483
25484
25485 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25486 PyObject *resultobj;
25487 wxWindow *arg1 = (wxWindow *) 0 ;
25488 wxSize const &arg2_defvalue = wxDefaultSize ;
25489 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25490 wxSize temp2 ;
25491 PyObject * obj0 = 0 ;
25492 PyObject * obj1 = 0 ;
25493 char *kwnames[] = {
25494 (char *) "self",(char *) "size", NULL
25495 };
25496
25497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25499 if (SWIG_arg_fail(1)) SWIG_fail;
25500 if (obj1) {
25501 {
25502 arg2 = &temp2;
25503 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25504 }
25505 }
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25509
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 Py_INCREF(Py_None); resultobj = Py_None;
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25521 PyObject *resultobj;
25522 wxWindow *arg1 = (wxWindow *) 0 ;
25523 PyObject * obj0 = 0 ;
25524 char *kwnames[] = {
25525 (char *) "self", NULL
25526 };
25527
25528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25530 if (SWIG_arg_fail(1)) SWIG_fail;
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 (arg1)->Raise();
25534
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 Py_INCREF(Py_None); resultobj = Py_None;
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj;
25547 wxWindow *arg1 = (wxWindow *) 0 ;
25548 PyObject * obj0 = 0 ;
25549 char *kwnames[] = {
25550 (char *) "self", NULL
25551 };
25552
25553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25555 if (SWIG_arg_fail(1)) SWIG_fail;
25556 {
25557 PyThreadState* __tstate = wxPyBeginAllowThreads();
25558 (arg1)->Lower();
25559
25560 wxPyEndAllowThreads(__tstate);
25561 if (PyErr_Occurred()) SWIG_fail;
25562 }
25563 Py_INCREF(Py_None); resultobj = Py_None;
25564 return resultobj;
25565 fail:
25566 return NULL;
25567 }
25568
25569
25570 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25571 PyObject *resultobj;
25572 wxWindow *arg1 = (wxWindow *) 0 ;
25573 wxSize *arg2 = 0 ;
25574 wxSize temp2 ;
25575 PyObject * obj0 = 0 ;
25576 PyObject * obj1 = 0 ;
25577 char *kwnames[] = {
25578 (char *) "self",(char *) "size", NULL
25579 };
25580
25581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25583 if (SWIG_arg_fail(1)) SWIG_fail;
25584 {
25585 arg2 = &temp2;
25586 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25587 }
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 (arg1)->SetClientSize((wxSize const &)*arg2);
25591
25592 wxPyEndAllowThreads(__tstate);
25593 if (PyErr_Occurred()) SWIG_fail;
25594 }
25595 Py_INCREF(Py_None); resultobj = Py_None;
25596 return resultobj;
25597 fail:
25598 return NULL;
25599 }
25600
25601
25602 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25603 PyObject *resultobj;
25604 wxWindow *arg1 = (wxWindow *) 0 ;
25605 int arg2 ;
25606 int arg3 ;
25607 PyObject * obj0 = 0 ;
25608 PyObject * obj1 = 0 ;
25609 PyObject * obj2 = 0 ;
25610 char *kwnames[] = {
25611 (char *) "self",(char *) "width",(char *) "height", NULL
25612 };
25613
25614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25616 if (SWIG_arg_fail(1)) SWIG_fail;
25617 {
25618 arg2 = (int)(SWIG_As_int(obj1));
25619 if (SWIG_arg_fail(2)) SWIG_fail;
25620 }
25621 {
25622 arg3 = (int)(SWIG_As_int(obj2));
25623 if (SWIG_arg_fail(3)) SWIG_fail;
25624 }
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 (arg1)->SetClientSize(arg2,arg3);
25628
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 Py_INCREF(Py_None); resultobj = Py_None;
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25640 PyObject *resultobj;
25641 wxWindow *arg1 = (wxWindow *) 0 ;
25642 wxRect *arg2 = 0 ;
25643 wxRect temp2 ;
25644 PyObject * obj0 = 0 ;
25645 PyObject * obj1 = 0 ;
25646 char *kwnames[] = {
25647 (char *) "self",(char *) "rect", NULL
25648 };
25649
25650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25652 if (SWIG_arg_fail(1)) SWIG_fail;
25653 {
25654 arg2 = &temp2;
25655 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25656 }
25657 {
25658 PyThreadState* __tstate = wxPyBeginAllowThreads();
25659 (arg1)->SetClientSize((wxRect const &)*arg2);
25660
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 Py_INCREF(Py_None); resultobj = Py_None;
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25672 PyObject *resultobj;
25673 wxWindow *arg1 = (wxWindow *) 0 ;
25674 wxPoint result;
25675 PyObject * obj0 = 0 ;
25676 char *kwnames[] = {
25677 (char *) "self", NULL
25678 };
25679
25680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25682 if (SWIG_arg_fail(1)) SWIG_fail;
25683 {
25684 PyThreadState* __tstate = wxPyBeginAllowThreads();
25685 result = (arg1)->GetPosition();
25686
25687 wxPyEndAllowThreads(__tstate);
25688 if (PyErr_Occurred()) SWIG_fail;
25689 }
25690 {
25691 wxPoint * resultptr;
25692 resultptr = new wxPoint((wxPoint &)(result));
25693 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25694 }
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj;
25703 wxWindow *arg1 = (wxWindow *) 0 ;
25704 int *arg2 = (int *) 0 ;
25705 int *arg3 = (int *) 0 ;
25706 int temp2 ;
25707 int res2 = 0 ;
25708 int temp3 ;
25709 int res3 = 0 ;
25710 PyObject * obj0 = 0 ;
25711 char *kwnames[] = {
25712 (char *) "self", NULL
25713 };
25714
25715 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25716 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25719 if (SWIG_arg_fail(1)) SWIG_fail;
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 (arg1)->GetPosition(arg2,arg3);
25723
25724 wxPyEndAllowThreads(__tstate);
25725 if (PyErr_Occurred()) SWIG_fail;
25726 }
25727 Py_INCREF(Py_None); resultobj = Py_None;
25728 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25729 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25730 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25731 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25732 return resultobj;
25733 fail:
25734 return NULL;
25735 }
25736
25737
25738 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25739 PyObject *resultobj;
25740 wxWindow *arg1 = (wxWindow *) 0 ;
25741 wxSize result;
25742 PyObject * obj0 = 0 ;
25743 char *kwnames[] = {
25744 (char *) "self", NULL
25745 };
25746
25747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25749 if (SWIG_arg_fail(1)) SWIG_fail;
25750 {
25751 PyThreadState* __tstate = wxPyBeginAllowThreads();
25752 result = ((wxWindow const *)arg1)->GetSize();
25753
25754 wxPyEndAllowThreads(__tstate);
25755 if (PyErr_Occurred()) SWIG_fail;
25756 }
25757 {
25758 wxSize * resultptr;
25759 resultptr = new wxSize((wxSize &)(result));
25760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25761 }
25762 return resultobj;
25763 fail:
25764 return NULL;
25765 }
25766
25767
25768 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25769 PyObject *resultobj;
25770 wxWindow *arg1 = (wxWindow *) 0 ;
25771 int *arg2 = (int *) 0 ;
25772 int *arg3 = (int *) 0 ;
25773 int temp2 ;
25774 int res2 = 0 ;
25775 int temp3 ;
25776 int res3 = 0 ;
25777 PyObject * obj0 = 0 ;
25778 char *kwnames[] = {
25779 (char *) "self", NULL
25780 };
25781
25782 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25783 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25786 if (SWIG_arg_fail(1)) SWIG_fail;
25787 {
25788 PyThreadState* __tstate = wxPyBeginAllowThreads();
25789 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25790
25791 wxPyEndAllowThreads(__tstate);
25792 if (PyErr_Occurred()) SWIG_fail;
25793 }
25794 Py_INCREF(Py_None); resultobj = Py_None;
25795 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25796 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25797 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25798 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj;
25807 wxWindow *arg1 = (wxWindow *) 0 ;
25808 wxRect result;
25809 PyObject * obj0 = 0 ;
25810 char *kwnames[] = {
25811 (char *) "self", NULL
25812 };
25813
25814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25816 if (SWIG_arg_fail(1)) SWIG_fail;
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 result = ((wxWindow const *)arg1)->GetRect();
25820
25821 wxPyEndAllowThreads(__tstate);
25822 if (PyErr_Occurred()) SWIG_fail;
25823 }
25824 {
25825 wxRect * resultptr;
25826 resultptr = new wxRect((wxRect &)(result));
25827 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25828 }
25829 return resultobj;
25830 fail:
25831 return NULL;
25832 }
25833
25834
25835 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25836 PyObject *resultobj;
25837 wxWindow *arg1 = (wxWindow *) 0 ;
25838 wxSize result;
25839 PyObject * obj0 = 0 ;
25840 char *kwnames[] = {
25841 (char *) "self", NULL
25842 };
25843
25844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25846 if (SWIG_arg_fail(1)) SWIG_fail;
25847 {
25848 PyThreadState* __tstate = wxPyBeginAllowThreads();
25849 result = ((wxWindow const *)arg1)->GetClientSize();
25850
25851 wxPyEndAllowThreads(__tstate);
25852 if (PyErr_Occurred()) SWIG_fail;
25853 }
25854 {
25855 wxSize * resultptr;
25856 resultptr = new wxSize((wxSize &)(result));
25857 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25858 }
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj;
25867 wxWindow *arg1 = (wxWindow *) 0 ;
25868 int *arg2 = (int *) 0 ;
25869 int *arg3 = (int *) 0 ;
25870 int temp2 ;
25871 int res2 = 0 ;
25872 int temp3 ;
25873 int res3 = 0 ;
25874 PyObject * obj0 = 0 ;
25875 char *kwnames[] = {
25876 (char *) "self", NULL
25877 };
25878
25879 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25880 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25883 if (SWIG_arg_fail(1)) SWIG_fail;
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25887
25888 wxPyEndAllowThreads(__tstate);
25889 if (PyErr_Occurred()) SWIG_fail;
25890 }
25891 Py_INCREF(Py_None); resultobj = Py_None;
25892 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25893 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25894 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25895 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25896 return resultobj;
25897 fail:
25898 return NULL;
25899 }
25900
25901
25902 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25903 PyObject *resultobj;
25904 wxWindow *arg1 = (wxWindow *) 0 ;
25905 wxPoint result;
25906 PyObject * obj0 = 0 ;
25907 char *kwnames[] = {
25908 (char *) "self", NULL
25909 };
25910
25911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25913 if (SWIG_arg_fail(1)) SWIG_fail;
25914 {
25915 PyThreadState* __tstate = wxPyBeginAllowThreads();
25916 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25917
25918 wxPyEndAllowThreads(__tstate);
25919 if (PyErr_Occurred()) SWIG_fail;
25920 }
25921 {
25922 wxPoint * resultptr;
25923 resultptr = new wxPoint((wxPoint &)(result));
25924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25925 }
25926 return resultobj;
25927 fail:
25928 return NULL;
25929 }
25930
25931
25932 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25933 PyObject *resultobj;
25934 wxWindow *arg1 = (wxWindow *) 0 ;
25935 wxRect result;
25936 PyObject * obj0 = 0 ;
25937 char *kwnames[] = {
25938 (char *) "self", NULL
25939 };
25940
25941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25943 if (SWIG_arg_fail(1)) SWIG_fail;
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 result = ((wxWindow const *)arg1)->GetClientRect();
25947
25948 wxPyEndAllowThreads(__tstate);
25949 if (PyErr_Occurred()) SWIG_fail;
25950 }
25951 {
25952 wxRect * resultptr;
25953 resultptr = new wxRect((wxRect &)(result));
25954 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25955 }
25956 return resultobj;
25957 fail:
25958 return NULL;
25959 }
25960
25961
25962 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25963 PyObject *resultobj;
25964 wxWindow *arg1 = (wxWindow *) 0 ;
25965 wxSize result;
25966 PyObject * obj0 = 0 ;
25967 char *kwnames[] = {
25968 (char *) "self", NULL
25969 };
25970
25971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25973 if (SWIG_arg_fail(1)) SWIG_fail;
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 result = ((wxWindow const *)arg1)->GetBestSize();
25977
25978 wxPyEndAllowThreads(__tstate);
25979 if (PyErr_Occurred()) SWIG_fail;
25980 }
25981 {
25982 wxSize * resultptr;
25983 resultptr = new wxSize((wxSize &)(result));
25984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25985 }
25986 return resultobj;
25987 fail:
25988 return NULL;
25989 }
25990
25991
25992 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25993 PyObject *resultobj;
25994 wxWindow *arg1 = (wxWindow *) 0 ;
25995 int *arg2 = (int *) 0 ;
25996 int *arg3 = (int *) 0 ;
25997 int temp2 ;
25998 int res2 = 0 ;
25999 int temp3 ;
26000 int res3 = 0 ;
26001 PyObject * obj0 = 0 ;
26002 char *kwnames[] = {
26003 (char *) "self", NULL
26004 };
26005
26006 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26007 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26010 if (SWIG_arg_fail(1)) SWIG_fail;
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26014
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 Py_INCREF(Py_None); resultobj = Py_None;
26019 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26020 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26021 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26022 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26030 PyObject *resultobj;
26031 wxWindow *arg1 = (wxWindow *) 0 ;
26032 PyObject * obj0 = 0 ;
26033 char *kwnames[] = {
26034 (char *) "self", NULL
26035 };
26036
26037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26039 if (SWIG_arg_fail(1)) SWIG_fail;
26040 {
26041 PyThreadState* __tstate = wxPyBeginAllowThreads();
26042 (arg1)->InvalidateBestSize();
26043
26044 wxPyEndAllowThreads(__tstate);
26045 if (PyErr_Occurred()) SWIG_fail;
26046 }
26047 Py_INCREF(Py_None); resultobj = Py_None;
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj;
26056 wxWindow *arg1 = (wxWindow *) 0 ;
26057 wxSize result;
26058 PyObject * obj0 = 0 ;
26059 char *kwnames[] = {
26060 (char *) "self", NULL
26061 };
26062
26063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26065 if (SWIG_arg_fail(1)) SWIG_fail;
26066 {
26067 PyThreadState* __tstate = wxPyBeginAllowThreads();
26068 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26069
26070 wxPyEndAllowThreads(__tstate);
26071 if (PyErr_Occurred()) SWIG_fail;
26072 }
26073 {
26074 wxSize * resultptr;
26075 resultptr = new wxSize((wxSize &)(result));
26076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26077 }
26078 return resultobj;
26079 fail:
26080 return NULL;
26081 }
26082
26083
26084 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26085 PyObject *resultobj;
26086 wxWindow *arg1 = (wxWindow *) 0 ;
26087 wxSize result;
26088 PyObject * obj0 = 0 ;
26089 char *kwnames[] = {
26090 (char *) "self", NULL
26091 };
26092
26093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26095 if (SWIG_arg_fail(1)) SWIG_fail;
26096 {
26097 PyThreadState* __tstate = wxPyBeginAllowThreads();
26098 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26099
26100 wxPyEndAllowThreads(__tstate);
26101 if (PyErr_Occurred()) SWIG_fail;
26102 }
26103 {
26104 wxSize * resultptr;
26105 resultptr = new wxSize((wxSize &)(result));
26106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26107 }
26108 return resultobj;
26109 fail:
26110 return NULL;
26111 }
26112
26113
26114 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26115 PyObject *resultobj;
26116 wxWindow *arg1 = (wxWindow *) 0 ;
26117 int arg2 = (int) wxBOTH ;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char *kwnames[] = {
26121 (char *) "self",(char *) "direction", NULL
26122 };
26123
26124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26126 if (SWIG_arg_fail(1)) SWIG_fail;
26127 if (obj1) {
26128 {
26129 arg2 = (int)(SWIG_As_int(obj1));
26130 if (SWIG_arg_fail(2)) SWIG_fail;
26131 }
26132 }
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 (arg1)->Center(arg2);
26136
26137 wxPyEndAllowThreads(__tstate);
26138 if (PyErr_Occurred()) SWIG_fail;
26139 }
26140 Py_INCREF(Py_None); resultobj = Py_None;
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj;
26149 wxWindow *arg1 = (wxWindow *) 0 ;
26150 int arg2 = (int) wxBOTH ;
26151 PyObject * obj0 = 0 ;
26152 PyObject * obj1 = 0 ;
26153 char *kwnames[] = {
26154 (char *) "self",(char *) "dir", NULL
26155 };
26156
26157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26159 if (SWIG_arg_fail(1)) SWIG_fail;
26160 if (obj1) {
26161 {
26162 arg2 = (int)(SWIG_As_int(obj1));
26163 if (SWIG_arg_fail(2)) SWIG_fail;
26164 }
26165 }
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 (arg1)->CenterOnScreen(arg2);
26169
26170 wxPyEndAllowThreads(__tstate);
26171 if (PyErr_Occurred()) SWIG_fail;
26172 }
26173 Py_INCREF(Py_None); resultobj = Py_None;
26174 return resultobj;
26175 fail:
26176 return NULL;
26177 }
26178
26179
26180 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26181 PyObject *resultobj;
26182 wxWindow *arg1 = (wxWindow *) 0 ;
26183 int arg2 = (int) wxBOTH ;
26184 PyObject * obj0 = 0 ;
26185 PyObject * obj1 = 0 ;
26186 char *kwnames[] = {
26187 (char *) "self",(char *) "dir", NULL
26188 };
26189
26190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26192 if (SWIG_arg_fail(1)) SWIG_fail;
26193 if (obj1) {
26194 {
26195 arg2 = (int)(SWIG_As_int(obj1));
26196 if (SWIG_arg_fail(2)) SWIG_fail;
26197 }
26198 }
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 (arg1)->CenterOnParent(arg2);
26202
26203 wxPyEndAllowThreads(__tstate);
26204 if (PyErr_Occurred()) SWIG_fail;
26205 }
26206 Py_INCREF(Py_None); resultobj = Py_None;
26207 return resultobj;
26208 fail:
26209 return NULL;
26210 }
26211
26212
26213 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26214 PyObject *resultobj;
26215 wxWindow *arg1 = (wxWindow *) 0 ;
26216 PyObject * obj0 = 0 ;
26217 char *kwnames[] = {
26218 (char *) "self", NULL
26219 };
26220
26221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26223 if (SWIG_arg_fail(1)) SWIG_fail;
26224 {
26225 PyThreadState* __tstate = wxPyBeginAllowThreads();
26226 (arg1)->Fit();
26227
26228 wxPyEndAllowThreads(__tstate);
26229 if (PyErr_Occurred()) SWIG_fail;
26230 }
26231 Py_INCREF(Py_None); resultobj = Py_None;
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26239 PyObject *resultobj;
26240 wxWindow *arg1 = (wxWindow *) 0 ;
26241 PyObject * obj0 = 0 ;
26242 char *kwnames[] = {
26243 (char *) "self", NULL
26244 };
26245
26246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26248 if (SWIG_arg_fail(1)) SWIG_fail;
26249 {
26250 PyThreadState* __tstate = wxPyBeginAllowThreads();
26251 (arg1)->FitInside();
26252
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 Py_INCREF(Py_None); resultobj = Py_None;
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26264 PyObject *resultobj;
26265 wxWindow *arg1 = (wxWindow *) 0 ;
26266 int arg2 ;
26267 int arg3 ;
26268 int arg4 = (int) -1 ;
26269 int arg5 = (int) -1 ;
26270 int arg6 = (int) -1 ;
26271 int arg7 = (int) -1 ;
26272 PyObject * obj0 = 0 ;
26273 PyObject * obj1 = 0 ;
26274 PyObject * obj2 = 0 ;
26275 PyObject * obj3 = 0 ;
26276 PyObject * obj4 = 0 ;
26277 PyObject * obj5 = 0 ;
26278 PyObject * obj6 = 0 ;
26279 char *kwnames[] = {
26280 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26281 };
26282
26283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26285 if (SWIG_arg_fail(1)) SWIG_fail;
26286 {
26287 arg2 = (int)(SWIG_As_int(obj1));
26288 if (SWIG_arg_fail(2)) SWIG_fail;
26289 }
26290 {
26291 arg3 = (int)(SWIG_As_int(obj2));
26292 if (SWIG_arg_fail(3)) SWIG_fail;
26293 }
26294 if (obj3) {
26295 {
26296 arg4 = (int)(SWIG_As_int(obj3));
26297 if (SWIG_arg_fail(4)) SWIG_fail;
26298 }
26299 }
26300 if (obj4) {
26301 {
26302 arg5 = (int)(SWIG_As_int(obj4));
26303 if (SWIG_arg_fail(5)) SWIG_fail;
26304 }
26305 }
26306 if (obj5) {
26307 {
26308 arg6 = (int)(SWIG_As_int(obj5));
26309 if (SWIG_arg_fail(6)) SWIG_fail;
26310 }
26311 }
26312 if (obj6) {
26313 {
26314 arg7 = (int)(SWIG_As_int(obj6));
26315 if (SWIG_arg_fail(7)) SWIG_fail;
26316 }
26317 }
26318 {
26319 PyThreadState* __tstate = wxPyBeginAllowThreads();
26320 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26321
26322 wxPyEndAllowThreads(__tstate);
26323 if (PyErr_Occurred()) SWIG_fail;
26324 }
26325 Py_INCREF(Py_None); resultobj = Py_None;
26326 return resultobj;
26327 fail:
26328 return NULL;
26329 }
26330
26331
26332 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26333 PyObject *resultobj;
26334 wxWindow *arg1 = (wxWindow *) 0 ;
26335 wxSize *arg2 = 0 ;
26336 wxSize const &arg3_defvalue = wxDefaultSize ;
26337 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26338 wxSize const &arg4_defvalue = wxDefaultSize ;
26339 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26340 wxSize temp2 ;
26341 wxSize temp3 ;
26342 wxSize temp4 ;
26343 PyObject * obj0 = 0 ;
26344 PyObject * obj1 = 0 ;
26345 PyObject * obj2 = 0 ;
26346 PyObject * obj3 = 0 ;
26347 char *kwnames[] = {
26348 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26349 };
26350
26351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26353 if (SWIG_arg_fail(1)) SWIG_fail;
26354 {
26355 arg2 = &temp2;
26356 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26357 }
26358 if (obj2) {
26359 {
26360 arg3 = &temp3;
26361 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26362 }
26363 }
26364 if (obj3) {
26365 {
26366 arg4 = &temp4;
26367 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26368 }
26369 }
26370 {
26371 PyThreadState* __tstate = wxPyBeginAllowThreads();
26372 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26373
26374 wxPyEndAllowThreads(__tstate);
26375 if (PyErr_Occurred()) SWIG_fail;
26376 }
26377 Py_INCREF(Py_None); resultobj = Py_None;
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26385 PyObject *resultobj;
26386 wxWindow *arg1 = (wxWindow *) 0 ;
26387 int arg2 ;
26388 int arg3 ;
26389 int arg4 = (int) -1 ;
26390 int arg5 = (int) -1 ;
26391 PyObject * obj0 = 0 ;
26392 PyObject * obj1 = 0 ;
26393 PyObject * obj2 = 0 ;
26394 PyObject * obj3 = 0 ;
26395 PyObject * obj4 = 0 ;
26396 char *kwnames[] = {
26397 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26398 };
26399
26400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26402 if (SWIG_arg_fail(1)) SWIG_fail;
26403 {
26404 arg2 = (int)(SWIG_As_int(obj1));
26405 if (SWIG_arg_fail(2)) SWIG_fail;
26406 }
26407 {
26408 arg3 = (int)(SWIG_As_int(obj2));
26409 if (SWIG_arg_fail(3)) SWIG_fail;
26410 }
26411 if (obj3) {
26412 {
26413 arg4 = (int)(SWIG_As_int(obj3));
26414 if (SWIG_arg_fail(4)) SWIG_fail;
26415 }
26416 }
26417 if (obj4) {
26418 {
26419 arg5 = (int)(SWIG_As_int(obj4));
26420 if (SWIG_arg_fail(5)) SWIG_fail;
26421 }
26422 }
26423 {
26424 PyThreadState* __tstate = wxPyBeginAllowThreads();
26425 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26426
26427 wxPyEndAllowThreads(__tstate);
26428 if (PyErr_Occurred()) SWIG_fail;
26429 }
26430 Py_INCREF(Py_None); resultobj = Py_None;
26431 return resultobj;
26432 fail:
26433 return NULL;
26434 }
26435
26436
26437 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26438 PyObject *resultobj;
26439 wxWindow *arg1 = (wxWindow *) 0 ;
26440 wxSize *arg2 = 0 ;
26441 wxSize const &arg3_defvalue = wxDefaultSize ;
26442 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26443 wxSize temp2 ;
26444 wxSize temp3 ;
26445 PyObject * obj0 = 0 ;
26446 PyObject * obj1 = 0 ;
26447 PyObject * obj2 = 0 ;
26448 char *kwnames[] = {
26449 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26450 };
26451
26452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26454 if (SWIG_arg_fail(1)) SWIG_fail;
26455 {
26456 arg2 = &temp2;
26457 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26458 }
26459 if (obj2) {
26460 {
26461 arg3 = &temp3;
26462 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26463 }
26464 }
26465 {
26466 PyThreadState* __tstate = wxPyBeginAllowThreads();
26467 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26468
26469 wxPyEndAllowThreads(__tstate);
26470 if (PyErr_Occurred()) SWIG_fail;
26471 }
26472 Py_INCREF(Py_None); resultobj = Py_None;
26473 return resultobj;
26474 fail:
26475 return NULL;
26476 }
26477
26478
26479 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26480 PyObject *resultobj;
26481 wxWindow *arg1 = (wxWindow *) 0 ;
26482 wxSize result;
26483 PyObject * obj0 = 0 ;
26484 char *kwnames[] = {
26485 (char *) "self", NULL
26486 };
26487
26488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26490 if (SWIG_arg_fail(1)) SWIG_fail;
26491 {
26492 PyThreadState* __tstate = wxPyBeginAllowThreads();
26493 result = ((wxWindow const *)arg1)->GetMaxSize();
26494
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 {
26499 wxSize * resultptr;
26500 resultptr = new wxSize((wxSize &)(result));
26501 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26502 }
26503 return resultobj;
26504 fail:
26505 return NULL;
26506 }
26507
26508
26509 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26510 PyObject *resultobj;
26511 wxWindow *arg1 = (wxWindow *) 0 ;
26512 wxSize result;
26513 PyObject * obj0 = 0 ;
26514 char *kwnames[] = {
26515 (char *) "self", NULL
26516 };
26517
26518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26520 if (SWIG_arg_fail(1)) SWIG_fail;
26521 {
26522 PyThreadState* __tstate = wxPyBeginAllowThreads();
26523 result = ((wxWindow const *)arg1)->GetMinSize();
26524
26525 wxPyEndAllowThreads(__tstate);
26526 if (PyErr_Occurred()) SWIG_fail;
26527 }
26528 {
26529 wxSize * resultptr;
26530 resultptr = new wxSize((wxSize &)(result));
26531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26532 }
26533 return resultobj;
26534 fail:
26535 return NULL;
26536 }
26537
26538
26539 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26540 PyObject *resultobj;
26541 wxWindow *arg1 = (wxWindow *) 0 ;
26542 wxSize *arg2 = 0 ;
26543 wxSize temp2 ;
26544 PyObject * obj0 = 0 ;
26545 PyObject * obj1 = 0 ;
26546 char *kwnames[] = {
26547 (char *) "self",(char *) "minSize", NULL
26548 };
26549
26550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26552 if (SWIG_arg_fail(1)) SWIG_fail;
26553 {
26554 arg2 = &temp2;
26555 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26556 }
26557 {
26558 PyThreadState* __tstate = wxPyBeginAllowThreads();
26559 (arg1)->SetMinSize((wxSize const &)*arg2);
26560
26561 wxPyEndAllowThreads(__tstate);
26562 if (PyErr_Occurred()) SWIG_fail;
26563 }
26564 Py_INCREF(Py_None); resultobj = Py_None;
26565 return resultobj;
26566 fail:
26567 return NULL;
26568 }
26569
26570
26571 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26572 PyObject *resultobj;
26573 wxWindow *arg1 = (wxWindow *) 0 ;
26574 wxSize *arg2 = 0 ;
26575 wxSize temp2 ;
26576 PyObject * obj0 = 0 ;
26577 PyObject * obj1 = 0 ;
26578 char *kwnames[] = {
26579 (char *) "self",(char *) "maxSize", NULL
26580 };
26581
26582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26584 if (SWIG_arg_fail(1)) SWIG_fail;
26585 {
26586 arg2 = &temp2;
26587 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26588 }
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 (arg1)->SetMaxSize((wxSize const &)*arg2);
26592
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 Py_INCREF(Py_None); resultobj = Py_None;
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26604 PyObject *resultobj;
26605 wxWindow *arg1 = (wxWindow *) 0 ;
26606 int result;
26607 PyObject * obj0 = 0 ;
26608 char *kwnames[] = {
26609 (char *) "self", NULL
26610 };
26611
26612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26614 if (SWIG_arg_fail(1)) SWIG_fail;
26615 {
26616 PyThreadState* __tstate = wxPyBeginAllowThreads();
26617 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26618
26619 wxPyEndAllowThreads(__tstate);
26620 if (PyErr_Occurred()) SWIG_fail;
26621 }
26622 {
26623 resultobj = SWIG_From_int((int)(result));
26624 }
26625 return resultobj;
26626 fail:
26627 return NULL;
26628 }
26629
26630
26631 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26632 PyObject *resultobj;
26633 wxWindow *arg1 = (wxWindow *) 0 ;
26634 int result;
26635 PyObject * obj0 = 0 ;
26636 char *kwnames[] = {
26637 (char *) "self", NULL
26638 };
26639
26640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26642 if (SWIG_arg_fail(1)) SWIG_fail;
26643 {
26644 PyThreadState* __tstate = wxPyBeginAllowThreads();
26645 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26646
26647 wxPyEndAllowThreads(__tstate);
26648 if (PyErr_Occurred()) SWIG_fail;
26649 }
26650 {
26651 resultobj = SWIG_From_int((int)(result));
26652 }
26653 return resultobj;
26654 fail:
26655 return NULL;
26656 }
26657
26658
26659 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj;
26661 wxWindow *arg1 = (wxWindow *) 0 ;
26662 int result;
26663 PyObject * obj0 = 0 ;
26664 char *kwnames[] = {
26665 (char *) "self", NULL
26666 };
26667
26668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26670 if (SWIG_arg_fail(1)) SWIG_fail;
26671 {
26672 PyThreadState* __tstate = wxPyBeginAllowThreads();
26673 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26674
26675 wxPyEndAllowThreads(__tstate);
26676 if (PyErr_Occurred()) SWIG_fail;
26677 }
26678 {
26679 resultobj = SWIG_From_int((int)(result));
26680 }
26681 return resultobj;
26682 fail:
26683 return NULL;
26684 }
26685
26686
26687 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26688 PyObject *resultobj;
26689 wxWindow *arg1 = (wxWindow *) 0 ;
26690 int result;
26691 PyObject * obj0 = 0 ;
26692 char *kwnames[] = {
26693 (char *) "self", NULL
26694 };
26695
26696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26698 if (SWIG_arg_fail(1)) SWIG_fail;
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26702
26703 wxPyEndAllowThreads(__tstate);
26704 if (PyErr_Occurred()) SWIG_fail;
26705 }
26706 {
26707 resultobj = SWIG_From_int((int)(result));
26708 }
26709 return resultobj;
26710 fail:
26711 return NULL;
26712 }
26713
26714
26715 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26716 PyObject *resultobj;
26717 wxWindow *arg1 = (wxWindow *) 0 ;
26718 wxSize *arg2 = 0 ;
26719 wxSize temp2 ;
26720 PyObject * obj0 = 0 ;
26721 PyObject * obj1 = 0 ;
26722 char *kwnames[] = {
26723 (char *) "self",(char *) "size", NULL
26724 };
26725
26726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26728 if (SWIG_arg_fail(1)) SWIG_fail;
26729 {
26730 arg2 = &temp2;
26731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26732 }
26733 {
26734 PyThreadState* __tstate = wxPyBeginAllowThreads();
26735 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26736
26737 wxPyEndAllowThreads(__tstate);
26738 if (PyErr_Occurred()) SWIG_fail;
26739 }
26740 Py_INCREF(Py_None); resultobj = Py_None;
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj;
26749 wxWindow *arg1 = (wxWindow *) 0 ;
26750 int arg2 ;
26751 int arg3 ;
26752 PyObject * obj0 = 0 ;
26753 PyObject * obj1 = 0 ;
26754 PyObject * obj2 = 0 ;
26755 char *kwnames[] = {
26756 (char *) "self",(char *) "w",(char *) "h", NULL
26757 };
26758
26759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26761 if (SWIG_arg_fail(1)) SWIG_fail;
26762 {
26763 arg2 = (int)(SWIG_As_int(obj1));
26764 if (SWIG_arg_fail(2)) SWIG_fail;
26765 }
26766 {
26767 arg3 = (int)(SWIG_As_int(obj2));
26768 if (SWIG_arg_fail(3)) SWIG_fail;
26769 }
26770 {
26771 PyThreadState* __tstate = wxPyBeginAllowThreads();
26772 (arg1)->SetVirtualSize(arg2,arg3);
26773
26774 wxPyEndAllowThreads(__tstate);
26775 if (PyErr_Occurred()) SWIG_fail;
26776 }
26777 Py_INCREF(Py_None); resultobj = Py_None;
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj;
26786 wxWindow *arg1 = (wxWindow *) 0 ;
26787 wxSize result;
26788 PyObject * obj0 = 0 ;
26789 char *kwnames[] = {
26790 (char *) "self", NULL
26791 };
26792
26793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26795 if (SWIG_arg_fail(1)) SWIG_fail;
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = ((wxWindow const *)arg1)->GetVirtualSize();
26799
26800 wxPyEndAllowThreads(__tstate);
26801 if (PyErr_Occurred()) SWIG_fail;
26802 }
26803 {
26804 wxSize * resultptr;
26805 resultptr = new wxSize((wxSize &)(result));
26806 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26807 }
26808 return resultobj;
26809 fail:
26810 return NULL;
26811 }
26812
26813
26814 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26815 PyObject *resultobj;
26816 wxWindow *arg1 = (wxWindow *) 0 ;
26817 int *arg2 = (int *) 0 ;
26818 int *arg3 = (int *) 0 ;
26819 int temp2 ;
26820 int res2 = 0 ;
26821 int temp3 ;
26822 int res3 = 0 ;
26823 PyObject * obj0 = 0 ;
26824 char *kwnames[] = {
26825 (char *) "self", NULL
26826 };
26827
26828 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26829 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26832 if (SWIG_arg_fail(1)) SWIG_fail;
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26836
26837 wxPyEndAllowThreads(__tstate);
26838 if (PyErr_Occurred()) SWIG_fail;
26839 }
26840 Py_INCREF(Py_None); resultobj = Py_None;
26841 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26842 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26843 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26844 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26845 return resultobj;
26846 fail:
26847 return NULL;
26848 }
26849
26850
26851 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26852 PyObject *resultobj;
26853 wxWindow *arg1 = (wxWindow *) 0 ;
26854 wxSize result;
26855 PyObject * obj0 = 0 ;
26856 char *kwnames[] = {
26857 (char *) "self", NULL
26858 };
26859
26860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26862 if (SWIG_arg_fail(1)) SWIG_fail;
26863 {
26864 PyThreadState* __tstate = wxPyBeginAllowThreads();
26865 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26866
26867 wxPyEndAllowThreads(__tstate);
26868 if (PyErr_Occurred()) SWIG_fail;
26869 }
26870 {
26871 wxSize * resultptr;
26872 resultptr = new wxSize((wxSize &)(result));
26873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26874 }
26875 return resultobj;
26876 fail:
26877 return NULL;
26878 }
26879
26880
26881 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26882 PyObject *resultobj;
26883 wxWindow *arg1 = (wxWindow *) 0 ;
26884 bool arg2 = (bool) true ;
26885 bool result;
26886 PyObject * obj0 = 0 ;
26887 PyObject * obj1 = 0 ;
26888 char *kwnames[] = {
26889 (char *) "self",(char *) "show", NULL
26890 };
26891
26892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26894 if (SWIG_arg_fail(1)) SWIG_fail;
26895 if (obj1) {
26896 {
26897 arg2 = (bool)(SWIG_As_bool(obj1));
26898 if (SWIG_arg_fail(2)) SWIG_fail;
26899 }
26900 }
26901 {
26902 PyThreadState* __tstate = wxPyBeginAllowThreads();
26903 result = (bool)(arg1)->Show(arg2);
26904
26905 wxPyEndAllowThreads(__tstate);
26906 if (PyErr_Occurred()) SWIG_fail;
26907 }
26908 {
26909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26910 }
26911 return resultobj;
26912 fail:
26913 return NULL;
26914 }
26915
26916
26917 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj;
26919 wxWindow *arg1 = (wxWindow *) 0 ;
26920 bool result;
26921 PyObject * obj0 = 0 ;
26922 char *kwnames[] = {
26923 (char *) "self", NULL
26924 };
26925
26926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26928 if (SWIG_arg_fail(1)) SWIG_fail;
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 result = (bool)(arg1)->Hide();
26932
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 {
26937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26938 }
26939 return resultobj;
26940 fail:
26941 return NULL;
26942 }
26943
26944
26945 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26946 PyObject *resultobj;
26947 wxWindow *arg1 = (wxWindow *) 0 ;
26948 bool arg2 = (bool) true ;
26949 bool result;
26950 PyObject * obj0 = 0 ;
26951 PyObject * obj1 = 0 ;
26952 char *kwnames[] = {
26953 (char *) "self",(char *) "enable", NULL
26954 };
26955
26956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26958 if (SWIG_arg_fail(1)) SWIG_fail;
26959 if (obj1) {
26960 {
26961 arg2 = (bool)(SWIG_As_bool(obj1));
26962 if (SWIG_arg_fail(2)) SWIG_fail;
26963 }
26964 }
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = (bool)(arg1)->Enable(arg2);
26968
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 {
26973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26974 }
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj;
26983 wxWindow *arg1 = (wxWindow *) 0 ;
26984 bool result;
26985 PyObject * obj0 = 0 ;
26986 char *kwnames[] = {
26987 (char *) "self", NULL
26988 };
26989
26990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26992 if (SWIG_arg_fail(1)) SWIG_fail;
26993 {
26994 PyThreadState* __tstate = wxPyBeginAllowThreads();
26995 result = (bool)(arg1)->Disable();
26996
26997 wxPyEndAllowThreads(__tstate);
26998 if (PyErr_Occurred()) SWIG_fail;
26999 }
27000 {
27001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27002 }
27003 return resultobj;
27004 fail:
27005 return NULL;
27006 }
27007
27008
27009 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27010 PyObject *resultobj;
27011 wxWindow *arg1 = (wxWindow *) 0 ;
27012 bool result;
27013 PyObject * obj0 = 0 ;
27014 char *kwnames[] = {
27015 (char *) "self", NULL
27016 };
27017
27018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27020 if (SWIG_arg_fail(1)) SWIG_fail;
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 result = (bool)((wxWindow const *)arg1)->IsShown();
27024
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 {
27029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27030 }
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27038 PyObject *resultobj;
27039 wxWindow *arg1 = (wxWindow *) 0 ;
27040 bool result;
27041 PyObject * obj0 = 0 ;
27042 char *kwnames[] = {
27043 (char *) "self", NULL
27044 };
27045
27046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27048 if (SWIG_arg_fail(1)) SWIG_fail;
27049 {
27050 PyThreadState* __tstate = wxPyBeginAllowThreads();
27051 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27052
27053 wxPyEndAllowThreads(__tstate);
27054 if (PyErr_Occurred()) SWIG_fail;
27055 }
27056 {
27057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27058 }
27059 return resultobj;
27060 fail:
27061 return NULL;
27062 }
27063
27064
27065 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27066 PyObject *resultobj;
27067 wxWindow *arg1 = (wxWindow *) 0 ;
27068 long arg2 ;
27069 PyObject * obj0 = 0 ;
27070 PyObject * obj1 = 0 ;
27071 char *kwnames[] = {
27072 (char *) "self",(char *) "style", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 {
27079 arg2 = (long)(SWIG_As_long(obj1));
27080 if (SWIG_arg_fail(2)) SWIG_fail;
27081 }
27082 {
27083 PyThreadState* __tstate = wxPyBeginAllowThreads();
27084 (arg1)->SetWindowStyleFlag(arg2);
27085
27086 wxPyEndAllowThreads(__tstate);
27087 if (PyErr_Occurred()) SWIG_fail;
27088 }
27089 Py_INCREF(Py_None); resultobj = Py_None;
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj;
27098 wxWindow *arg1 = (wxWindow *) 0 ;
27099 long result;
27100 PyObject * obj0 = 0 ;
27101 char *kwnames[] = {
27102 (char *) "self", NULL
27103 };
27104
27105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27107 if (SWIG_arg_fail(1)) SWIG_fail;
27108 {
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27111
27112 wxPyEndAllowThreads(__tstate);
27113 if (PyErr_Occurred()) SWIG_fail;
27114 }
27115 {
27116 resultobj = SWIG_From_long((long)(result));
27117 }
27118 return resultobj;
27119 fail:
27120 return NULL;
27121 }
27122
27123
27124 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27125 PyObject *resultobj;
27126 wxWindow *arg1 = (wxWindow *) 0 ;
27127 int arg2 ;
27128 bool result;
27129 PyObject * obj0 = 0 ;
27130 PyObject * obj1 = 0 ;
27131 char *kwnames[] = {
27132 (char *) "self",(char *) "flag", NULL
27133 };
27134
27135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27137 if (SWIG_arg_fail(1)) SWIG_fail;
27138 {
27139 arg2 = (int)(SWIG_As_int(obj1));
27140 if (SWIG_arg_fail(2)) SWIG_fail;
27141 }
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27145
27146 wxPyEndAllowThreads(__tstate);
27147 if (PyErr_Occurred()) SWIG_fail;
27148 }
27149 {
27150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27151 }
27152 return resultobj;
27153 fail:
27154 return NULL;
27155 }
27156
27157
27158 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27159 PyObject *resultobj;
27160 wxWindow *arg1 = (wxWindow *) 0 ;
27161 bool result;
27162 PyObject * obj0 = 0 ;
27163 char *kwnames[] = {
27164 (char *) "self", NULL
27165 };
27166
27167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",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 = (bool)((wxWindow const *)arg1)->IsRetained();
27173
27174 wxPyEndAllowThreads(__tstate);
27175 if (PyErr_Occurred()) SWIG_fail;
27176 }
27177 {
27178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27179 }
27180 return resultobj;
27181 fail:
27182 return NULL;
27183 }
27184
27185
27186 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27187 PyObject *resultobj;
27188 wxWindow *arg1 = (wxWindow *) 0 ;
27189 long arg2 ;
27190 PyObject * obj0 = 0 ;
27191 PyObject * obj1 = 0 ;
27192 char *kwnames[] = {
27193 (char *) "self",(char *) "exStyle", NULL
27194 };
27195
27196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27198 if (SWIG_arg_fail(1)) SWIG_fail;
27199 {
27200 arg2 = (long)(SWIG_As_long(obj1));
27201 if (SWIG_arg_fail(2)) SWIG_fail;
27202 }
27203 {
27204 PyThreadState* __tstate = wxPyBeginAllowThreads();
27205 (arg1)->SetExtraStyle(arg2);
27206
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 Py_INCREF(Py_None); resultobj = Py_None;
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27218 PyObject *resultobj;
27219 wxWindow *arg1 = (wxWindow *) 0 ;
27220 long result;
27221 PyObject * obj0 = 0 ;
27222 char *kwnames[] = {
27223 (char *) "self", NULL
27224 };
27225
27226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27228 if (SWIG_arg_fail(1)) SWIG_fail;
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27232
27233 wxPyEndAllowThreads(__tstate);
27234 if (PyErr_Occurred()) SWIG_fail;
27235 }
27236 {
27237 resultobj = SWIG_From_long((long)(result));
27238 }
27239 return resultobj;
27240 fail:
27241 return NULL;
27242 }
27243
27244
27245 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27246 PyObject *resultobj;
27247 wxWindow *arg1 = (wxWindow *) 0 ;
27248 bool arg2 = (bool) true ;
27249 PyObject * obj0 = 0 ;
27250 PyObject * obj1 = 0 ;
27251 char *kwnames[] = {
27252 (char *) "self",(char *) "modal", NULL
27253 };
27254
27255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27257 if (SWIG_arg_fail(1)) SWIG_fail;
27258 if (obj1) {
27259 {
27260 arg2 = (bool)(SWIG_As_bool(obj1));
27261 if (SWIG_arg_fail(2)) SWIG_fail;
27262 }
27263 }
27264 {
27265 PyThreadState* __tstate = wxPyBeginAllowThreads();
27266 (arg1)->MakeModal(arg2);
27267
27268 wxPyEndAllowThreads(__tstate);
27269 if (PyErr_Occurred()) SWIG_fail;
27270 }
27271 Py_INCREF(Py_None); resultobj = Py_None;
27272 return resultobj;
27273 fail:
27274 return NULL;
27275 }
27276
27277
27278 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27279 PyObject *resultobj;
27280 wxWindow *arg1 = (wxWindow *) 0 ;
27281 bool arg2 ;
27282 PyObject * obj0 = 0 ;
27283 PyObject * obj1 = 0 ;
27284 char *kwnames[] = {
27285 (char *) "self",(char *) "enableTheme", NULL
27286 };
27287
27288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27290 if (SWIG_arg_fail(1)) SWIG_fail;
27291 {
27292 arg2 = (bool)(SWIG_As_bool(obj1));
27293 if (SWIG_arg_fail(2)) SWIG_fail;
27294 }
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 (arg1)->SetThemeEnabled(arg2);
27298
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 Py_INCREF(Py_None); resultobj = Py_None;
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27310 PyObject *resultobj;
27311 wxWindow *arg1 = (wxWindow *) 0 ;
27312 bool result;
27313 PyObject * obj0 = 0 ;
27314 char *kwnames[] = {
27315 (char *) "self", NULL
27316 };
27317
27318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27320 if (SWIG_arg_fail(1)) SWIG_fail;
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27324
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 {
27329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27330 }
27331 return resultobj;
27332 fail:
27333 return NULL;
27334 }
27335
27336
27337 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27338 PyObject *resultobj;
27339 wxWindow *arg1 = (wxWindow *) 0 ;
27340 PyObject * obj0 = 0 ;
27341 char *kwnames[] = {
27342 (char *) "self", NULL
27343 };
27344
27345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27347 if (SWIG_arg_fail(1)) SWIG_fail;
27348 {
27349 PyThreadState* __tstate = wxPyBeginAllowThreads();
27350 (arg1)->SetFocus();
27351
27352 wxPyEndAllowThreads(__tstate);
27353 if (PyErr_Occurred()) SWIG_fail;
27354 }
27355 Py_INCREF(Py_None); resultobj = Py_None;
27356 return resultobj;
27357 fail:
27358 return NULL;
27359 }
27360
27361
27362 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27363 PyObject *resultobj;
27364 wxWindow *arg1 = (wxWindow *) 0 ;
27365 PyObject * obj0 = 0 ;
27366 char *kwnames[] = {
27367 (char *) "self", NULL
27368 };
27369
27370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27372 if (SWIG_arg_fail(1)) SWIG_fail;
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 (arg1)->SetFocusFromKbd();
27376
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 Py_INCREF(Py_None); resultobj = Py_None;
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27388 PyObject *resultobj;
27389 wxWindow *result;
27390 char *kwnames[] = {
27391 NULL
27392 };
27393
27394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27395 {
27396 if (!wxPyCheckForApp()) SWIG_fail;
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 result = (wxWindow *)wxWindow::FindFocus();
27399
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 {
27404 resultobj = wxPyMake_wxObject(result, 0);
27405 }
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27413 PyObject *resultobj;
27414 wxWindow *arg1 = (wxWindow *) 0 ;
27415 bool result;
27416 PyObject * obj0 = 0 ;
27417 char *kwnames[] = {
27418 (char *) "self", NULL
27419 };
27420
27421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27423 if (SWIG_arg_fail(1)) SWIG_fail;
27424 {
27425 PyThreadState* __tstate = wxPyBeginAllowThreads();
27426 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27427
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 {
27432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27433 }
27434 return resultobj;
27435 fail:
27436 return NULL;
27437 }
27438
27439
27440 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27441 PyObject *resultobj;
27442 wxWindow *arg1 = (wxWindow *) 0 ;
27443 bool result;
27444 PyObject * obj0 = 0 ;
27445 char *kwnames[] = {
27446 (char *) "self", NULL
27447 };
27448
27449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27451 if (SWIG_arg_fail(1)) SWIG_fail;
27452 {
27453 PyThreadState* __tstate = wxPyBeginAllowThreads();
27454 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27455
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 {
27460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27461 }
27462 return resultobj;
27463 fail:
27464 return NULL;
27465 }
27466
27467
27468 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27469 PyObject *resultobj;
27470 wxWindow *arg1 = (wxWindow *) 0 ;
27471 wxWindow *result;
27472 PyObject * obj0 = 0 ;
27473 char *kwnames[] = {
27474 (char *) "self", NULL
27475 };
27476
27477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27479 if (SWIG_arg_fail(1)) SWIG_fail;
27480 {
27481 PyThreadState* __tstate = wxPyBeginAllowThreads();
27482 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27483
27484 wxPyEndAllowThreads(__tstate);
27485 if (PyErr_Occurred()) SWIG_fail;
27486 }
27487 {
27488 resultobj = wxPyMake_wxObject(result, 0);
27489 }
27490 return resultobj;
27491 fail:
27492 return NULL;
27493 }
27494
27495
27496 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27497 PyObject *resultobj;
27498 wxWindow *arg1 = (wxWindow *) 0 ;
27499 wxWindow *arg2 = (wxWindow *) 0 ;
27500 wxWindow *result;
27501 PyObject * obj0 = 0 ;
27502 PyObject * obj1 = 0 ;
27503 char *kwnames[] = {
27504 (char *) "self",(char *) "child", NULL
27505 };
27506
27507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27509 if (SWIG_arg_fail(1)) SWIG_fail;
27510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27511 if (SWIG_arg_fail(2)) SWIG_fail;
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27515
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 {
27520 resultobj = wxPyMake_wxObject(result, 0);
27521 }
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27529 PyObject *resultobj;
27530 wxWindow *arg1 = (wxWindow *) 0 ;
27531 wxWindow *arg2 = (wxWindow *) 0 ;
27532 PyObject * obj0 = 0 ;
27533 PyObject * obj1 = 0 ;
27534 char *kwnames[] = {
27535 (char *) "self",(char *) "win", NULL
27536 };
27537
27538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27540 if (SWIG_arg_fail(1)) SWIG_fail;
27541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27542 if (SWIG_arg_fail(2)) SWIG_fail;
27543 {
27544 PyThreadState* __tstate = wxPyBeginAllowThreads();
27545 (arg1)->SetTmpDefaultItem(arg2);
27546
27547 wxPyEndAllowThreads(__tstate);
27548 if (PyErr_Occurred()) SWIG_fail;
27549 }
27550 Py_INCREF(Py_None); resultobj = Py_None;
27551 return resultobj;
27552 fail:
27553 return NULL;
27554 }
27555
27556
27557 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27558 PyObject *resultobj;
27559 wxWindow *arg1 = (wxWindow *) 0 ;
27560 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27561 bool result;
27562 PyObject * obj0 = 0 ;
27563 PyObject * obj1 = 0 ;
27564 char *kwnames[] = {
27565 (char *) "self",(char *) "flags", NULL
27566 };
27567
27568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27570 if (SWIG_arg_fail(1)) SWIG_fail;
27571 if (obj1) {
27572 {
27573 arg2 = (int)(SWIG_As_int(obj1));
27574 if (SWIG_arg_fail(2)) SWIG_fail;
27575 }
27576 }
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 result = (bool)(arg1)->Navigate(arg2);
27580
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 {
27585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27586 }
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 wxWindow *arg2 = (wxWindow *) 0 ;
27597 PyObject * obj0 = 0 ;
27598 PyObject * obj1 = 0 ;
27599 char *kwnames[] = {
27600 (char *) "self",(char *) "win", NULL
27601 };
27602
27603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27605 if (SWIG_arg_fail(1)) SWIG_fail;
27606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27607 if (SWIG_arg_fail(2)) SWIG_fail;
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 (arg1)->MoveAfterInTabOrder(arg2);
27611
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 Py_INCREF(Py_None); resultobj = Py_None;
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27623 PyObject *resultobj;
27624 wxWindow *arg1 = (wxWindow *) 0 ;
27625 wxWindow *arg2 = (wxWindow *) 0 ;
27626 PyObject * obj0 = 0 ;
27627 PyObject * obj1 = 0 ;
27628 char *kwnames[] = {
27629 (char *) "self",(char *) "win", NULL
27630 };
27631
27632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27636 if (SWIG_arg_fail(2)) SWIG_fail;
27637 {
27638 PyThreadState* __tstate = wxPyBeginAllowThreads();
27639 (arg1)->MoveBeforeInTabOrder(arg2);
27640
27641 wxPyEndAllowThreads(__tstate);
27642 if (PyErr_Occurred()) SWIG_fail;
27643 }
27644 Py_INCREF(Py_None); resultobj = Py_None;
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxWindow *arg1 = (wxWindow *) 0 ;
27654 PyObject *result;
27655 PyObject * obj0 = 0 ;
27656 char *kwnames[] = {
27657 (char *) "self", NULL
27658 };
27659
27660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27662 if (SWIG_arg_fail(1)) SWIG_fail;
27663 {
27664 PyThreadState* __tstate = wxPyBeginAllowThreads();
27665 result = (PyObject *)wxWindow_GetChildren(arg1);
27666
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 resultobj = result;
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27678 PyObject *resultobj;
27679 wxWindow *arg1 = (wxWindow *) 0 ;
27680 wxWindow *result;
27681 PyObject * obj0 = 0 ;
27682 char *kwnames[] = {
27683 (char *) "self", NULL
27684 };
27685
27686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27688 if (SWIG_arg_fail(1)) SWIG_fail;
27689 {
27690 PyThreadState* __tstate = wxPyBeginAllowThreads();
27691 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27692
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 {
27697 resultobj = wxPyMake_wxObject(result, 0);
27698 }
27699 return resultobj;
27700 fail:
27701 return NULL;
27702 }
27703
27704
27705 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27706 PyObject *resultobj;
27707 wxWindow *arg1 = (wxWindow *) 0 ;
27708 wxWindow *result;
27709 PyObject * obj0 = 0 ;
27710 char *kwnames[] = {
27711 (char *) "self", NULL
27712 };
27713
27714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27716 if (SWIG_arg_fail(1)) SWIG_fail;
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27720
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 {
27725 resultobj = wxPyMake_wxObject(result, 0);
27726 }
27727 return resultobj;
27728 fail:
27729 return NULL;
27730 }
27731
27732
27733 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27734 PyObject *resultobj;
27735 wxWindow *arg1 = (wxWindow *) 0 ;
27736 bool result;
27737 PyObject * obj0 = 0 ;
27738 char *kwnames[] = {
27739 (char *) "self", NULL
27740 };
27741
27742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27744 if (SWIG_arg_fail(1)) SWIG_fail;
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27748
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 {
27753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27754 }
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27762 PyObject *resultobj;
27763 wxWindow *arg1 = (wxWindow *) 0 ;
27764 wxWindow *arg2 = (wxWindow *) 0 ;
27765 bool result;
27766 PyObject * obj0 = 0 ;
27767 PyObject * obj1 = 0 ;
27768 char *kwnames[] = {
27769 (char *) "self",(char *) "newParent", NULL
27770 };
27771
27772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27774 if (SWIG_arg_fail(1)) SWIG_fail;
27775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(2)) SWIG_fail;
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 result = (bool)(arg1)->Reparent(arg2);
27780
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj;
27795 wxWindow *arg1 = (wxWindow *) 0 ;
27796 wxWindow *arg2 = (wxWindow *) 0 ;
27797 PyObject * obj0 = 0 ;
27798 PyObject * obj1 = 0 ;
27799 char *kwnames[] = {
27800 (char *) "self",(char *) "child", NULL
27801 };
27802
27803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27805 if (SWIG_arg_fail(1)) SWIG_fail;
27806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27807 if (SWIG_arg_fail(2)) SWIG_fail;
27808 {
27809 PyThreadState* __tstate = wxPyBeginAllowThreads();
27810 (arg1)->AddChild(arg2);
27811
27812 wxPyEndAllowThreads(__tstate);
27813 if (PyErr_Occurred()) SWIG_fail;
27814 }
27815 Py_INCREF(Py_None); resultobj = Py_None;
27816 return resultobj;
27817 fail:
27818 return NULL;
27819 }
27820
27821
27822 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27823 PyObject *resultobj;
27824 wxWindow *arg1 = (wxWindow *) 0 ;
27825 wxWindow *arg2 = (wxWindow *) 0 ;
27826 PyObject * obj0 = 0 ;
27827 PyObject * obj1 = 0 ;
27828 char *kwnames[] = {
27829 (char *) "self",(char *) "child", NULL
27830 };
27831
27832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27834 if (SWIG_arg_fail(1)) SWIG_fail;
27835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27836 if (SWIG_arg_fail(2)) SWIG_fail;
27837 {
27838 PyThreadState* __tstate = wxPyBeginAllowThreads();
27839 (arg1)->RemoveChild(arg2);
27840
27841 wxPyEndAllowThreads(__tstate);
27842 if (PyErr_Occurred()) SWIG_fail;
27843 }
27844 Py_INCREF(Py_None); resultobj = Py_None;
27845 return resultobj;
27846 fail:
27847 return NULL;
27848 }
27849
27850
27851 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27852 PyObject *resultobj;
27853 wxWindow *arg1 = (wxWindow *) 0 ;
27854 long arg2 ;
27855 wxWindow *result;
27856 PyObject * obj0 = 0 ;
27857 PyObject * obj1 = 0 ;
27858 char *kwnames[] = {
27859 (char *) "self",(char *) "winid", NULL
27860 };
27861
27862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27864 if (SWIG_arg_fail(1)) SWIG_fail;
27865 {
27866 arg2 = (long)(SWIG_As_long(obj1));
27867 if (SWIG_arg_fail(2)) SWIG_fail;
27868 }
27869 {
27870 PyThreadState* __tstate = wxPyBeginAllowThreads();
27871 result = (wxWindow *)(arg1)->FindWindow(arg2);
27872
27873 wxPyEndAllowThreads(__tstate);
27874 if (PyErr_Occurred()) SWIG_fail;
27875 }
27876 {
27877 resultobj = wxPyMake_wxObject(result, 0);
27878 }
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27886 PyObject *resultobj;
27887 wxWindow *arg1 = (wxWindow *) 0 ;
27888 wxString *arg2 = 0 ;
27889 wxWindow *result;
27890 bool temp2 = false ;
27891 PyObject * obj0 = 0 ;
27892 PyObject * obj1 = 0 ;
27893 char *kwnames[] = {
27894 (char *) "self",(char *) "name", NULL
27895 };
27896
27897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
27902 if (arg2 == NULL) SWIG_fail;
27903 temp2 = true;
27904 }
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27908
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 {
27913 resultobj = wxPyMake_wxObject(result, 0);
27914 }
27915 {
27916 if (temp2)
27917 delete arg2;
27918 }
27919 return resultobj;
27920 fail:
27921 {
27922 if (temp2)
27923 delete arg2;
27924 }
27925 return NULL;
27926 }
27927
27928
27929 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27930 PyObject *resultobj;
27931 wxWindow *arg1 = (wxWindow *) 0 ;
27932 wxEvtHandler *result;
27933 PyObject * obj0 = 0 ;
27934 char *kwnames[] = {
27935 (char *) "self", NULL
27936 };
27937
27938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27940 if (SWIG_arg_fail(1)) SWIG_fail;
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27944
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 resultobj = wxPyMake_wxObject(result, 0);
27950 }
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27958 PyObject *resultobj;
27959 wxWindow *arg1 = (wxWindow *) 0 ;
27960 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27961 PyObject * obj0 = 0 ;
27962 PyObject * obj1 = 0 ;
27963 char *kwnames[] = {
27964 (char *) "self",(char *) "handler", NULL
27965 };
27966
27967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27969 if (SWIG_arg_fail(1)) SWIG_fail;
27970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27971 if (SWIG_arg_fail(2)) SWIG_fail;
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 (arg1)->SetEventHandler(arg2);
27975
27976 wxPyEndAllowThreads(__tstate);
27977 if (PyErr_Occurred()) SWIG_fail;
27978 }
27979 Py_INCREF(Py_None); resultobj = Py_None;
27980 return resultobj;
27981 fail:
27982 return NULL;
27983 }
27984
27985
27986 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27987 PyObject *resultobj;
27988 wxWindow *arg1 = (wxWindow *) 0 ;
27989 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char *kwnames[] = {
27993 (char *) "self",(char *) "handler", NULL
27994 };
27995
27996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27998 if (SWIG_arg_fail(1)) SWIG_fail;
27999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28000 if (SWIG_arg_fail(2)) SWIG_fail;
28001 {
28002 PyThreadState* __tstate = wxPyBeginAllowThreads();
28003 (arg1)->PushEventHandler(arg2);
28004
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 Py_INCREF(Py_None); resultobj = Py_None;
28009 return resultobj;
28010 fail:
28011 return NULL;
28012 }
28013
28014
28015 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28016 PyObject *resultobj;
28017 wxWindow *arg1 = (wxWindow *) 0 ;
28018 bool arg2 = (bool) false ;
28019 wxEvtHandler *result;
28020 PyObject * obj0 = 0 ;
28021 PyObject * obj1 = 0 ;
28022 char *kwnames[] = {
28023 (char *) "self",(char *) "deleteHandler", NULL
28024 };
28025
28026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28028 if (SWIG_arg_fail(1)) SWIG_fail;
28029 if (obj1) {
28030 {
28031 arg2 = (bool)(SWIG_As_bool(obj1));
28032 if (SWIG_arg_fail(2)) SWIG_fail;
28033 }
28034 }
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28038
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 {
28043 resultobj = wxPyMake_wxObject(result, 0);
28044 }
28045 return resultobj;
28046 fail:
28047 return NULL;
28048 }
28049
28050
28051 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28052 PyObject *resultobj;
28053 wxWindow *arg1 = (wxWindow *) 0 ;
28054 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28055 bool result;
28056 PyObject * obj0 = 0 ;
28057 PyObject * obj1 = 0 ;
28058 char *kwnames[] = {
28059 (char *) "self",(char *) "handler", NULL
28060 };
28061
28062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28064 if (SWIG_arg_fail(1)) SWIG_fail;
28065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28066 if (SWIG_arg_fail(2)) SWIG_fail;
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 result = (bool)(arg1)->RemoveEventHandler(arg2);
28070
28071 wxPyEndAllowThreads(__tstate);
28072 if (PyErr_Occurred()) SWIG_fail;
28073 }
28074 {
28075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28076 }
28077 return resultobj;
28078 fail:
28079 return NULL;
28080 }
28081
28082
28083 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28084 PyObject *resultobj;
28085 wxWindow *arg1 = (wxWindow *) 0 ;
28086 wxValidator *arg2 = 0 ;
28087 PyObject * obj0 = 0 ;
28088 PyObject * obj1 = 0 ;
28089 char *kwnames[] = {
28090 (char *) "self",(char *) "validator", NULL
28091 };
28092
28093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28095 if (SWIG_arg_fail(1)) SWIG_fail;
28096 {
28097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28098 if (SWIG_arg_fail(2)) SWIG_fail;
28099 if (arg2 == NULL) {
28100 SWIG_null_ref("wxValidator");
28101 }
28102 if (SWIG_arg_fail(2)) SWIG_fail;
28103 }
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 (arg1)->SetValidator((wxValidator const &)*arg2);
28107
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 Py_INCREF(Py_None); resultobj = Py_None;
28112 return resultobj;
28113 fail:
28114 return NULL;
28115 }
28116
28117
28118 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28119 PyObject *resultobj;
28120 wxWindow *arg1 = (wxWindow *) 0 ;
28121 wxValidator *result;
28122 PyObject * obj0 = 0 ;
28123 char *kwnames[] = {
28124 (char *) "self", NULL
28125 };
28126
28127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28129 if (SWIG_arg_fail(1)) SWIG_fail;
28130 {
28131 PyThreadState* __tstate = wxPyBeginAllowThreads();
28132 result = (wxValidator *)(arg1)->GetValidator();
28133
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 {
28138 resultobj = wxPyMake_wxObject(result, 0);
28139 }
28140 return resultobj;
28141 fail:
28142 return NULL;
28143 }
28144
28145
28146 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28147 PyObject *resultobj;
28148 wxWindow *arg1 = (wxWindow *) 0 ;
28149 bool result;
28150 PyObject * obj0 = 0 ;
28151 char *kwnames[] = {
28152 (char *) "self", NULL
28153 };
28154
28155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28157 if (SWIG_arg_fail(1)) SWIG_fail;
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 result = (bool)(arg1)->Validate();
28161
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 {
28166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28167 }
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28175 PyObject *resultobj;
28176 wxWindow *arg1 = (wxWindow *) 0 ;
28177 bool result;
28178 PyObject * obj0 = 0 ;
28179 char *kwnames[] = {
28180 (char *) "self", NULL
28181 };
28182
28183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28185 if (SWIG_arg_fail(1)) SWIG_fail;
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (bool)(arg1)->TransferDataToWindow();
28189
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 {
28194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28195 }
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj;
28204 wxWindow *arg1 = (wxWindow *) 0 ;
28205 bool result;
28206 PyObject * obj0 = 0 ;
28207 char *kwnames[] = {
28208 (char *) "self", NULL
28209 };
28210
28211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28213 if (SWIG_arg_fail(1)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (bool)(arg1)->TransferDataFromWindow();
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 {
28222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28223 }
28224 return resultobj;
28225 fail:
28226 return NULL;
28227 }
28228
28229
28230 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28231 PyObject *resultobj;
28232 wxWindow *arg1 = (wxWindow *) 0 ;
28233 PyObject * obj0 = 0 ;
28234 char *kwnames[] = {
28235 (char *) "self", NULL
28236 };
28237
28238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28240 if (SWIG_arg_fail(1)) SWIG_fail;
28241 {
28242 PyThreadState* __tstate = wxPyBeginAllowThreads();
28243 (arg1)->InitDialog();
28244
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 Py_INCREF(Py_None); resultobj = Py_None;
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28256 PyObject *resultobj;
28257 wxWindow *arg1 = (wxWindow *) 0 ;
28258 wxAcceleratorTable *arg2 = 0 ;
28259 PyObject * obj0 = 0 ;
28260 PyObject * obj1 = 0 ;
28261 char *kwnames[] = {
28262 (char *) "self",(char *) "accel", NULL
28263 };
28264
28265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28267 if (SWIG_arg_fail(1)) SWIG_fail;
28268 {
28269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28270 if (SWIG_arg_fail(2)) SWIG_fail;
28271 if (arg2 == NULL) {
28272 SWIG_null_ref("wxAcceleratorTable");
28273 }
28274 if (SWIG_arg_fail(2)) SWIG_fail;
28275 }
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28279
28280 wxPyEndAllowThreads(__tstate);
28281 if (PyErr_Occurred()) SWIG_fail;
28282 }
28283 Py_INCREF(Py_None); resultobj = Py_None;
28284 return resultobj;
28285 fail:
28286 return NULL;
28287 }
28288
28289
28290 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28291 PyObject *resultobj;
28292 wxWindow *arg1 = (wxWindow *) 0 ;
28293 wxAcceleratorTable *result;
28294 PyObject * obj0 = 0 ;
28295 char *kwnames[] = {
28296 (char *) "self", NULL
28297 };
28298
28299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) 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 {
28303 PyThreadState* __tstate = wxPyBeginAllowThreads();
28304 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28305
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28317 PyObject *resultobj;
28318 wxWindow *arg1 = (wxWindow *) 0 ;
28319 int arg2 ;
28320 int arg3 ;
28321 int arg4 ;
28322 bool result;
28323 PyObject * obj0 = 0 ;
28324 PyObject * obj1 = 0 ;
28325 PyObject * obj2 = 0 ;
28326 PyObject * obj3 = 0 ;
28327 char *kwnames[] = {
28328 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28329 };
28330
28331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28333 if (SWIG_arg_fail(1)) SWIG_fail;
28334 {
28335 arg2 = (int)(SWIG_As_int(obj1));
28336 if (SWIG_arg_fail(2)) SWIG_fail;
28337 }
28338 {
28339 arg3 = (int)(SWIG_As_int(obj2));
28340 if (SWIG_arg_fail(3)) SWIG_fail;
28341 }
28342 {
28343 arg4 = (int)(SWIG_As_int(obj3));
28344 if (SWIG_arg_fail(4)) SWIG_fail;
28345 }
28346 {
28347 PyThreadState* __tstate = wxPyBeginAllowThreads();
28348 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28349
28350 wxPyEndAllowThreads(__tstate);
28351 if (PyErr_Occurred()) SWIG_fail;
28352 }
28353 {
28354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28355 }
28356 return resultobj;
28357 fail:
28358 return NULL;
28359 }
28360
28361
28362 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28363 PyObject *resultobj;
28364 wxWindow *arg1 = (wxWindow *) 0 ;
28365 int arg2 ;
28366 bool result;
28367 PyObject * obj0 = 0 ;
28368 PyObject * obj1 = 0 ;
28369 char *kwnames[] = {
28370 (char *) "self",(char *) "hotkeyId", NULL
28371 };
28372
28373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28375 if (SWIG_arg_fail(1)) SWIG_fail;
28376 {
28377 arg2 = (int)(SWIG_As_int(obj1));
28378 if (SWIG_arg_fail(2)) SWIG_fail;
28379 }
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28383
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 {
28388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28389 }
28390 return resultobj;
28391 fail:
28392 return NULL;
28393 }
28394
28395
28396 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28397 PyObject *resultobj;
28398 wxWindow *arg1 = (wxWindow *) 0 ;
28399 wxPoint *arg2 = 0 ;
28400 wxPoint result;
28401 wxPoint temp2 ;
28402 PyObject * obj0 = 0 ;
28403 PyObject * obj1 = 0 ;
28404 char *kwnames[] = {
28405 (char *) "self",(char *) "pt", NULL
28406 };
28407
28408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28410 if (SWIG_arg_fail(1)) SWIG_fail;
28411 {
28412 arg2 = &temp2;
28413 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28414 }
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28418
28419 wxPyEndAllowThreads(__tstate);
28420 if (PyErr_Occurred()) SWIG_fail;
28421 }
28422 {
28423 wxPoint * resultptr;
28424 resultptr = new wxPoint((wxPoint &)(result));
28425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28426 }
28427 return resultobj;
28428 fail:
28429 return NULL;
28430 }
28431
28432
28433 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj;
28435 wxWindow *arg1 = (wxWindow *) 0 ;
28436 wxSize *arg2 = 0 ;
28437 wxSize result;
28438 wxSize temp2 ;
28439 PyObject * obj0 = 0 ;
28440 PyObject * obj1 = 0 ;
28441 char *kwnames[] = {
28442 (char *) "self",(char *) "sz", NULL
28443 };
28444
28445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28447 if (SWIG_arg_fail(1)) SWIG_fail;
28448 {
28449 arg2 = &temp2;
28450 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28451 }
28452 {
28453 PyThreadState* __tstate = wxPyBeginAllowThreads();
28454 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28455
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 wxSize * resultptr;
28461 resultptr = new wxSize((wxSize &)(result));
28462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28463 }
28464 return resultobj;
28465 fail:
28466 return NULL;
28467 }
28468
28469
28470 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28471 PyObject *resultobj;
28472 wxWindow *arg1 = (wxWindow *) 0 ;
28473 wxPoint *arg2 = 0 ;
28474 wxPoint result;
28475 wxPoint temp2 ;
28476 PyObject * obj0 = 0 ;
28477 PyObject * obj1 = 0 ;
28478 char *kwnames[] = {
28479 (char *) "self",(char *) "pt", NULL
28480 };
28481
28482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28484 if (SWIG_arg_fail(1)) SWIG_fail;
28485 {
28486 arg2 = &temp2;
28487 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28488 }
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28492
28493 wxPyEndAllowThreads(__tstate);
28494 if (PyErr_Occurred()) SWIG_fail;
28495 }
28496 {
28497 wxPoint * resultptr;
28498 resultptr = new wxPoint((wxPoint &)(result));
28499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28500 }
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28508 PyObject *resultobj;
28509 wxWindow *arg1 = (wxWindow *) 0 ;
28510 wxSize *arg2 = 0 ;
28511 wxSize result;
28512 wxSize temp2 ;
28513 PyObject * obj0 = 0 ;
28514 PyObject * obj1 = 0 ;
28515 char *kwnames[] = {
28516 (char *) "self",(char *) "sz", NULL
28517 };
28518
28519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(1)) SWIG_fail;
28522 {
28523 arg2 = &temp2;
28524 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28525 }
28526 {
28527 PyThreadState* __tstate = wxPyBeginAllowThreads();
28528 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28529
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 {
28534 wxSize * resultptr;
28535 resultptr = new wxSize((wxSize &)(result));
28536 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28537 }
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj;
28546 wxWindow *arg1 = (wxWindow *) 0 ;
28547 wxPoint *arg2 = 0 ;
28548 wxPoint result;
28549 wxPoint temp2 ;
28550 PyObject * obj0 = 0 ;
28551 PyObject * obj1 = 0 ;
28552 char *kwnames[] = {
28553 (char *) "self",(char *) "pt", NULL
28554 };
28555
28556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28558 if (SWIG_arg_fail(1)) SWIG_fail;
28559 {
28560 arg2 = &temp2;
28561 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28562 }
28563 {
28564 PyThreadState* __tstate = wxPyBeginAllowThreads();
28565 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28566
28567 wxPyEndAllowThreads(__tstate);
28568 if (PyErr_Occurred()) SWIG_fail;
28569 }
28570 {
28571 wxPoint * resultptr;
28572 resultptr = new wxPoint((wxPoint &)(result));
28573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28574 }
28575 return resultobj;
28576 fail:
28577 return NULL;
28578 }
28579
28580
28581 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28582 PyObject *resultobj;
28583 wxWindow *arg1 = (wxWindow *) 0 ;
28584 wxSize *arg2 = 0 ;
28585 wxSize result;
28586 wxSize temp2 ;
28587 PyObject * obj0 = 0 ;
28588 PyObject * obj1 = 0 ;
28589 char *kwnames[] = {
28590 (char *) "self",(char *) "sz", NULL
28591 };
28592
28593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28595 if (SWIG_arg_fail(1)) SWIG_fail;
28596 {
28597 arg2 = &temp2;
28598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28599 }
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28603
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 {
28608 wxSize * resultptr;
28609 resultptr = new wxSize((wxSize &)(result));
28610 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28619 PyObject *resultobj;
28620 wxWindow *arg1 = (wxWindow *) 0 ;
28621 int arg2 ;
28622 int arg3 ;
28623 PyObject * obj0 = 0 ;
28624 PyObject * obj1 = 0 ;
28625 PyObject * obj2 = 0 ;
28626 char *kwnames[] = {
28627 (char *) "self",(char *) "x",(char *) "y", NULL
28628 };
28629
28630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28632 if (SWIG_arg_fail(1)) SWIG_fail;
28633 {
28634 arg2 = (int)(SWIG_As_int(obj1));
28635 if (SWIG_arg_fail(2)) SWIG_fail;
28636 }
28637 {
28638 arg3 = (int)(SWIG_As_int(obj2));
28639 if (SWIG_arg_fail(3)) SWIG_fail;
28640 }
28641 {
28642 PyThreadState* __tstate = wxPyBeginAllowThreads();
28643 (arg1)->WarpPointer(arg2,arg3);
28644
28645 wxPyEndAllowThreads(__tstate);
28646 if (PyErr_Occurred()) SWIG_fail;
28647 }
28648 Py_INCREF(Py_None); resultobj = Py_None;
28649 return resultobj;
28650 fail:
28651 return NULL;
28652 }
28653
28654
28655 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28656 PyObject *resultobj;
28657 wxWindow *arg1 = (wxWindow *) 0 ;
28658 PyObject * obj0 = 0 ;
28659 char *kwnames[] = {
28660 (char *) "self", NULL
28661 };
28662
28663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28665 if (SWIG_arg_fail(1)) SWIG_fail;
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 (arg1)->CaptureMouse();
28669
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 Py_INCREF(Py_None); resultobj = Py_None;
28674 return resultobj;
28675 fail:
28676 return NULL;
28677 }
28678
28679
28680 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28681 PyObject *resultobj;
28682 wxWindow *arg1 = (wxWindow *) 0 ;
28683 PyObject * obj0 = 0 ;
28684 char *kwnames[] = {
28685 (char *) "self", NULL
28686 };
28687
28688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28690 if (SWIG_arg_fail(1)) SWIG_fail;
28691 {
28692 PyThreadState* __tstate = wxPyBeginAllowThreads();
28693 (arg1)->ReleaseMouse();
28694
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 Py_INCREF(Py_None); resultobj = Py_None;
28699 return resultobj;
28700 fail:
28701 return NULL;
28702 }
28703
28704
28705 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28706 PyObject *resultobj;
28707 wxWindow *result;
28708 char *kwnames[] = {
28709 NULL
28710 };
28711
28712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28713 {
28714 if (!wxPyCheckForApp()) SWIG_fail;
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 result = (wxWindow *)wxWindow::GetCapture();
28717
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 {
28722 resultobj = wxPyMake_wxObject(result, 0);
28723 }
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28731 PyObject *resultobj;
28732 wxWindow *arg1 = (wxWindow *) 0 ;
28733 bool result;
28734 PyObject * obj0 = 0 ;
28735 char *kwnames[] = {
28736 (char *) "self", NULL
28737 };
28738
28739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28741 if (SWIG_arg_fail(1)) SWIG_fail;
28742 {
28743 PyThreadState* __tstate = wxPyBeginAllowThreads();
28744 result = (bool)((wxWindow const *)arg1)->HasCapture();
28745
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 {
28750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28751 }
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj;
28760 wxWindow *arg1 = (wxWindow *) 0 ;
28761 bool arg2 = (bool) true ;
28762 wxRect *arg3 = (wxRect *) NULL ;
28763 PyObject * obj0 = 0 ;
28764 PyObject * obj1 = 0 ;
28765 PyObject * obj2 = 0 ;
28766 char *kwnames[] = {
28767 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28768 };
28769
28770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28772 if (SWIG_arg_fail(1)) SWIG_fail;
28773 if (obj1) {
28774 {
28775 arg2 = (bool)(SWIG_As_bool(obj1));
28776 if (SWIG_arg_fail(2)) SWIG_fail;
28777 }
28778 }
28779 if (obj2) {
28780 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28781 if (SWIG_arg_fail(3)) SWIG_fail;
28782 }
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28786
28787 wxPyEndAllowThreads(__tstate);
28788 if (PyErr_Occurred()) SWIG_fail;
28789 }
28790 Py_INCREF(Py_None); resultobj = Py_None;
28791 return resultobj;
28792 fail:
28793 return NULL;
28794 }
28795
28796
28797 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28798 PyObject *resultobj;
28799 wxWindow *arg1 = (wxWindow *) 0 ;
28800 wxRect *arg2 = 0 ;
28801 bool arg3 = (bool) true ;
28802 wxRect temp2 ;
28803 PyObject * obj0 = 0 ;
28804 PyObject * obj1 = 0 ;
28805 PyObject * obj2 = 0 ;
28806 char *kwnames[] = {
28807 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28808 };
28809
28810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28812 if (SWIG_arg_fail(1)) SWIG_fail;
28813 {
28814 arg2 = &temp2;
28815 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28816 }
28817 if (obj2) {
28818 {
28819 arg3 = (bool)(SWIG_As_bool(obj2));
28820 if (SWIG_arg_fail(3)) SWIG_fail;
28821 }
28822 }
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28826
28827 wxPyEndAllowThreads(__tstate);
28828 if (PyErr_Occurred()) SWIG_fail;
28829 }
28830 Py_INCREF(Py_None); resultobj = Py_None;
28831 return resultobj;
28832 fail:
28833 return NULL;
28834 }
28835
28836
28837 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28838 PyObject *resultobj;
28839 wxWindow *arg1 = (wxWindow *) 0 ;
28840 PyObject * obj0 = 0 ;
28841 char *kwnames[] = {
28842 (char *) "self", NULL
28843 };
28844
28845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28847 if (SWIG_arg_fail(1)) SWIG_fail;
28848 {
28849 PyThreadState* __tstate = wxPyBeginAllowThreads();
28850 (arg1)->Update();
28851
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 Py_INCREF(Py_None); resultobj = Py_None;
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28863 PyObject *resultobj;
28864 wxWindow *arg1 = (wxWindow *) 0 ;
28865 PyObject * obj0 = 0 ;
28866 char *kwnames[] = {
28867 (char *) "self", NULL
28868 };
28869
28870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28872 if (SWIG_arg_fail(1)) SWIG_fail;
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 (arg1)->ClearBackground();
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 Py_INCREF(Py_None); resultobj = Py_None;
28881 return resultobj;
28882 fail:
28883 return NULL;
28884 }
28885
28886
28887 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj;
28889 wxWindow *arg1 = (wxWindow *) 0 ;
28890 PyObject * obj0 = 0 ;
28891 char *kwnames[] = {
28892 (char *) "self", NULL
28893 };
28894
28895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28897 if (SWIG_arg_fail(1)) SWIG_fail;
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 (arg1)->Freeze();
28901
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 Py_INCREF(Py_None); resultobj = Py_None;
28906 return resultobj;
28907 fail:
28908 return NULL;
28909 }
28910
28911
28912 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28913 PyObject *resultobj;
28914 wxWindow *arg1 = (wxWindow *) 0 ;
28915 PyObject * obj0 = 0 ;
28916 char *kwnames[] = {
28917 (char *) "self", NULL
28918 };
28919
28920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28922 if (SWIG_arg_fail(1)) SWIG_fail;
28923 {
28924 PyThreadState* __tstate = wxPyBeginAllowThreads();
28925 (arg1)->Thaw();
28926
28927 wxPyEndAllowThreads(__tstate);
28928 if (PyErr_Occurred()) SWIG_fail;
28929 }
28930 Py_INCREF(Py_None); resultobj = Py_None;
28931 return resultobj;
28932 fail:
28933 return NULL;
28934 }
28935
28936
28937 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28938 PyObject *resultobj;
28939 wxWindow *arg1 = (wxWindow *) 0 ;
28940 wxDC *arg2 = 0 ;
28941 PyObject * obj0 = 0 ;
28942 PyObject * obj1 = 0 ;
28943 char *kwnames[] = {
28944 (char *) "self",(char *) "dc", NULL
28945 };
28946
28947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28949 if (SWIG_arg_fail(1)) SWIG_fail;
28950 {
28951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28952 if (SWIG_arg_fail(2)) SWIG_fail;
28953 if (arg2 == NULL) {
28954 SWIG_null_ref("wxDC");
28955 }
28956 if (SWIG_arg_fail(2)) SWIG_fail;
28957 }
28958 {
28959 PyThreadState* __tstate = wxPyBeginAllowThreads();
28960 (arg1)->PrepareDC(*arg2);
28961
28962 wxPyEndAllowThreads(__tstate);
28963 if (PyErr_Occurred()) SWIG_fail;
28964 }
28965 Py_INCREF(Py_None); resultobj = Py_None;
28966 return resultobj;
28967 fail:
28968 return NULL;
28969 }
28970
28971
28972 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28973 PyObject *resultobj;
28974 wxWindow *arg1 = (wxWindow *) 0 ;
28975 wxRegion *result;
28976 PyObject * obj0 = 0 ;
28977 char *kwnames[] = {
28978 (char *) "self", NULL
28979 };
28980
28981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28983 if (SWIG_arg_fail(1)) SWIG_fail;
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 {
28987 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28988 result = (wxRegion *) &_result_ref;
28989 }
28990
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29002 PyObject *resultobj;
29003 wxWindow *arg1 = (wxWindow *) 0 ;
29004 wxRect result;
29005 PyObject * obj0 = 0 ;
29006 char *kwnames[] = {
29007 (char *) "self", NULL
29008 };
29009
29010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29012 if (SWIG_arg_fail(1)) SWIG_fail;
29013 {
29014 PyThreadState* __tstate = wxPyBeginAllowThreads();
29015 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29016
29017 wxPyEndAllowThreads(__tstate);
29018 if (PyErr_Occurred()) SWIG_fail;
29019 }
29020 {
29021 wxRect * resultptr;
29022 resultptr = new wxRect((wxRect &)(result));
29023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29024 }
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj;
29033 wxWindow *arg1 = (wxWindow *) 0 ;
29034 int arg2 ;
29035 int arg3 ;
29036 int arg4 = (int) 1 ;
29037 int arg5 = (int) 1 ;
29038 bool result;
29039 PyObject * obj0 = 0 ;
29040 PyObject * obj1 = 0 ;
29041 PyObject * obj2 = 0 ;
29042 PyObject * obj3 = 0 ;
29043 PyObject * obj4 = 0 ;
29044 char *kwnames[] = {
29045 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29046 };
29047
29048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29050 if (SWIG_arg_fail(1)) SWIG_fail;
29051 {
29052 arg2 = (int)(SWIG_As_int(obj1));
29053 if (SWIG_arg_fail(2)) SWIG_fail;
29054 }
29055 {
29056 arg3 = (int)(SWIG_As_int(obj2));
29057 if (SWIG_arg_fail(3)) SWIG_fail;
29058 }
29059 if (obj3) {
29060 {
29061 arg4 = (int)(SWIG_As_int(obj3));
29062 if (SWIG_arg_fail(4)) SWIG_fail;
29063 }
29064 }
29065 if (obj4) {
29066 {
29067 arg5 = (int)(SWIG_As_int(obj4));
29068 if (SWIG_arg_fail(5)) SWIG_fail;
29069 }
29070 }
29071 {
29072 PyThreadState* __tstate = wxPyBeginAllowThreads();
29073 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29074
29075 wxPyEndAllowThreads(__tstate);
29076 if (PyErr_Occurred()) SWIG_fail;
29077 }
29078 {
29079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29080 }
29081 return resultobj;
29082 fail:
29083 return NULL;
29084 }
29085
29086
29087 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29088 PyObject *resultobj;
29089 wxWindow *arg1 = (wxWindow *) 0 ;
29090 wxPoint *arg2 = 0 ;
29091 bool result;
29092 wxPoint temp2 ;
29093 PyObject * obj0 = 0 ;
29094 PyObject * obj1 = 0 ;
29095 char *kwnames[] = {
29096 (char *) "self",(char *) "pt", NULL
29097 };
29098
29099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29101 if (SWIG_arg_fail(1)) SWIG_fail;
29102 {
29103 arg2 = &temp2;
29104 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29105 }
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29109
29110 wxPyEndAllowThreads(__tstate);
29111 if (PyErr_Occurred()) SWIG_fail;
29112 }
29113 {
29114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29115 }
29116 return resultobj;
29117 fail:
29118 return NULL;
29119 }
29120
29121
29122 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29123 PyObject *resultobj;
29124 wxWindow *arg1 = (wxWindow *) 0 ;
29125 wxRect *arg2 = 0 ;
29126 bool result;
29127 wxRect temp2 ;
29128 PyObject * obj0 = 0 ;
29129 PyObject * obj1 = 0 ;
29130 char *kwnames[] = {
29131 (char *) "self",(char *) "rect", NULL
29132 };
29133
29134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29136 if (SWIG_arg_fail(1)) SWIG_fail;
29137 {
29138 arg2 = &temp2;
29139 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29140 }
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29144
29145 wxPyEndAllowThreads(__tstate);
29146 if (PyErr_Occurred()) SWIG_fail;
29147 }
29148 {
29149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29150 }
29151 return resultobj;
29152 fail:
29153 return NULL;
29154 }
29155
29156
29157 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29158 PyObject *resultobj;
29159 wxWindow *arg1 = (wxWindow *) 0 ;
29160 wxVisualAttributes result;
29161 PyObject * obj0 = 0 ;
29162 char *kwnames[] = {
29163 (char *) "self", NULL
29164 };
29165
29166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29168 if (SWIG_arg_fail(1)) SWIG_fail;
29169 {
29170 PyThreadState* __tstate = wxPyBeginAllowThreads();
29171 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29172
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 {
29177 wxVisualAttributes * resultptr;
29178 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29180 }
29181 return resultobj;
29182 fail:
29183 return NULL;
29184 }
29185
29186
29187 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29188 PyObject *resultobj;
29189 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29190 wxVisualAttributes result;
29191 PyObject * obj0 = 0 ;
29192 char *kwnames[] = {
29193 (char *) "variant", NULL
29194 };
29195
29196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29197 if (obj0) {
29198 {
29199 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29200 if (SWIG_arg_fail(1)) SWIG_fail;
29201 }
29202 }
29203 {
29204 if (!wxPyCheckForApp()) SWIG_fail;
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29207
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 {
29212 wxVisualAttributes * resultptr;
29213 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29215 }
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29223 PyObject *resultobj;
29224 wxWindow *arg1 = (wxWindow *) 0 ;
29225 wxColour *arg2 = 0 ;
29226 bool result;
29227 wxColour temp2 ;
29228 PyObject * obj0 = 0 ;
29229 PyObject * obj1 = 0 ;
29230 char *kwnames[] = {
29231 (char *) "self",(char *) "colour", NULL
29232 };
29233
29234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29236 if (SWIG_arg_fail(1)) SWIG_fail;
29237 {
29238 arg2 = &temp2;
29239 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29240 }
29241 {
29242 PyThreadState* __tstate = wxPyBeginAllowThreads();
29243 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29244
29245 wxPyEndAllowThreads(__tstate);
29246 if (PyErr_Occurred()) SWIG_fail;
29247 }
29248 {
29249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29250 }
29251 return resultobj;
29252 fail:
29253 return NULL;
29254 }
29255
29256
29257 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29258 PyObject *resultobj;
29259 wxWindow *arg1 = (wxWindow *) 0 ;
29260 wxColour *arg2 = 0 ;
29261 wxColour temp2 ;
29262 PyObject * obj0 = 0 ;
29263 PyObject * obj1 = 0 ;
29264 char *kwnames[] = {
29265 (char *) "self",(char *) "colour", NULL
29266 };
29267
29268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29270 if (SWIG_arg_fail(1)) SWIG_fail;
29271 {
29272 arg2 = &temp2;
29273 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29274 }
29275 {
29276 PyThreadState* __tstate = wxPyBeginAllowThreads();
29277 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29278
29279 wxPyEndAllowThreads(__tstate);
29280 if (PyErr_Occurred()) SWIG_fail;
29281 }
29282 Py_INCREF(Py_None); resultobj = Py_None;
29283 return resultobj;
29284 fail:
29285 return NULL;
29286 }
29287
29288
29289 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29290 PyObject *resultobj;
29291 wxWindow *arg1 = (wxWindow *) 0 ;
29292 wxColour *arg2 = 0 ;
29293 bool result;
29294 wxColour temp2 ;
29295 PyObject * obj0 = 0 ;
29296 PyObject * obj1 = 0 ;
29297 char *kwnames[] = {
29298 (char *) "self",(char *) "colour", NULL
29299 };
29300
29301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29303 if (SWIG_arg_fail(1)) SWIG_fail;
29304 {
29305 arg2 = &temp2;
29306 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29307 }
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29311
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 {
29316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29317 }
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj;
29326 wxWindow *arg1 = (wxWindow *) 0 ;
29327 wxColour *arg2 = 0 ;
29328 wxColour temp2 ;
29329 PyObject * obj0 = 0 ;
29330 PyObject * obj1 = 0 ;
29331 char *kwnames[] = {
29332 (char *) "self",(char *) "colour", NULL
29333 };
29334
29335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29337 if (SWIG_arg_fail(1)) SWIG_fail;
29338 {
29339 arg2 = &temp2;
29340 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29341 }
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29345
29346 wxPyEndAllowThreads(__tstate);
29347 if (PyErr_Occurred()) SWIG_fail;
29348 }
29349 Py_INCREF(Py_None); resultobj = Py_None;
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29357 PyObject *resultobj;
29358 wxWindow *arg1 = (wxWindow *) 0 ;
29359 wxColour result;
29360 PyObject * obj0 = 0 ;
29361 char *kwnames[] = {
29362 (char *) "self", NULL
29363 };
29364
29365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29367 if (SWIG_arg_fail(1)) SWIG_fail;
29368 {
29369 PyThreadState* __tstate = wxPyBeginAllowThreads();
29370 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29371
29372 wxPyEndAllowThreads(__tstate);
29373 if (PyErr_Occurred()) SWIG_fail;
29374 }
29375 {
29376 wxColour * resultptr;
29377 resultptr = new wxColour((wxColour &)(result));
29378 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29379 }
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29387 PyObject *resultobj;
29388 wxWindow *arg1 = (wxWindow *) 0 ;
29389 wxColour result;
29390 PyObject * obj0 = 0 ;
29391 char *kwnames[] = {
29392 (char *) "self", NULL
29393 };
29394
29395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29397 if (SWIG_arg_fail(1)) SWIG_fail;
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 result = ((wxWindow const *)arg1)->GetForegroundColour();
29401
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 {
29406 wxColour * resultptr;
29407 resultptr = new wxColour((wxColour &)(result));
29408 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29409 }
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29417 PyObject *resultobj;
29418 wxWindow *arg1 = (wxWindow *) 0 ;
29419 bool result;
29420 PyObject * obj0 = 0 ;
29421 char *kwnames[] = {
29422 (char *) "self", NULL
29423 };
29424
29425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29427 if (SWIG_arg_fail(1)) SWIG_fail;
29428 {
29429 PyThreadState* __tstate = wxPyBeginAllowThreads();
29430 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29431
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 {
29436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29437 }
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29445 PyObject *resultobj;
29446 wxWindow *arg1 = (wxWindow *) 0 ;
29447 bool result;
29448 PyObject * obj0 = 0 ;
29449 char *kwnames[] = {
29450 (char *) "self", NULL
29451 };
29452
29453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29455 if (SWIG_arg_fail(1)) SWIG_fail;
29456 {
29457 PyThreadState* __tstate = wxPyBeginAllowThreads();
29458 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29459
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 {
29464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29465 }
29466 return resultobj;
29467 fail:
29468 return NULL;
29469 }
29470
29471
29472 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29473 PyObject *resultobj;
29474 wxWindow *arg1 = (wxWindow *) 0 ;
29475 wxBackgroundStyle arg2 ;
29476 bool result;
29477 PyObject * obj0 = 0 ;
29478 PyObject * obj1 = 0 ;
29479 char *kwnames[] = {
29480 (char *) "self",(char *) "style", NULL
29481 };
29482
29483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29485 if (SWIG_arg_fail(1)) SWIG_fail;
29486 {
29487 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29488 if (SWIG_arg_fail(2)) SWIG_fail;
29489 }
29490 {
29491 PyThreadState* __tstate = wxPyBeginAllowThreads();
29492 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29493
29494 wxPyEndAllowThreads(__tstate);
29495 if (PyErr_Occurred()) SWIG_fail;
29496 }
29497 {
29498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29499 }
29500 return resultobj;
29501 fail:
29502 return NULL;
29503 }
29504
29505
29506 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29507 PyObject *resultobj;
29508 wxWindow *arg1 = (wxWindow *) 0 ;
29509 wxBackgroundStyle result;
29510 PyObject * obj0 = 0 ;
29511 char *kwnames[] = {
29512 (char *) "self", NULL
29513 };
29514
29515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29517 if (SWIG_arg_fail(1)) SWIG_fail;
29518 {
29519 PyThreadState* __tstate = wxPyBeginAllowThreads();
29520 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29521
29522 wxPyEndAllowThreads(__tstate);
29523 if (PyErr_Occurred()) SWIG_fail;
29524 }
29525 resultobj = SWIG_From_int((result));
29526 return resultobj;
29527 fail:
29528 return NULL;
29529 }
29530
29531
29532 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29533 PyObject *resultobj;
29534 wxWindow *arg1 = (wxWindow *) 0 ;
29535 bool result;
29536 PyObject * obj0 = 0 ;
29537 char *kwnames[] = {
29538 (char *) "self", NULL
29539 };
29540
29541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29543 if (SWIG_arg_fail(1)) SWIG_fail;
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = (bool)(arg1)->HasTransparentBackground();
29547
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 {
29552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29553 }
29554 return resultobj;
29555 fail:
29556 return NULL;
29557 }
29558
29559
29560 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29561 PyObject *resultobj;
29562 wxWindow *arg1 = (wxWindow *) 0 ;
29563 wxCursor *arg2 = 0 ;
29564 bool result;
29565 PyObject * obj0 = 0 ;
29566 PyObject * obj1 = 0 ;
29567 char *kwnames[] = {
29568 (char *) "self",(char *) "cursor", NULL
29569 };
29570
29571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29573 if (SWIG_arg_fail(1)) SWIG_fail;
29574 {
29575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29576 if (SWIG_arg_fail(2)) SWIG_fail;
29577 if (arg2 == NULL) {
29578 SWIG_null_ref("wxCursor");
29579 }
29580 if (SWIG_arg_fail(2)) SWIG_fail;
29581 }
29582 {
29583 PyThreadState* __tstate = wxPyBeginAllowThreads();
29584 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29585
29586 wxPyEndAllowThreads(__tstate);
29587 if (PyErr_Occurred()) SWIG_fail;
29588 }
29589 {
29590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29591 }
29592 return resultobj;
29593 fail:
29594 return NULL;
29595 }
29596
29597
29598 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29599 PyObject *resultobj;
29600 wxWindow *arg1 = (wxWindow *) 0 ;
29601 wxCursor result;
29602 PyObject * obj0 = 0 ;
29603 char *kwnames[] = {
29604 (char *) "self", NULL
29605 };
29606
29607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29609 if (SWIG_arg_fail(1)) SWIG_fail;
29610 {
29611 PyThreadState* __tstate = wxPyBeginAllowThreads();
29612 result = (arg1)->GetCursor();
29613
29614 wxPyEndAllowThreads(__tstate);
29615 if (PyErr_Occurred()) SWIG_fail;
29616 }
29617 {
29618 wxCursor * resultptr;
29619 resultptr = new wxCursor((wxCursor &)(result));
29620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29621 }
29622 return resultobj;
29623 fail:
29624 return NULL;
29625 }
29626
29627
29628 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29629 PyObject *resultobj;
29630 wxWindow *arg1 = (wxWindow *) 0 ;
29631 wxFont *arg2 = 0 ;
29632 bool result;
29633 PyObject * obj0 = 0 ;
29634 PyObject * obj1 = 0 ;
29635 char *kwnames[] = {
29636 (char *) "self",(char *) "font", NULL
29637 };
29638
29639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29641 if (SWIG_arg_fail(1)) SWIG_fail;
29642 {
29643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29644 if (SWIG_arg_fail(2)) SWIG_fail;
29645 if (arg2 == NULL) {
29646 SWIG_null_ref("wxFont");
29647 }
29648 if (SWIG_arg_fail(2)) SWIG_fail;
29649 }
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29653
29654 wxPyEndAllowThreads(__tstate);
29655 if (PyErr_Occurred()) SWIG_fail;
29656 }
29657 {
29658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29659 }
29660 return resultobj;
29661 fail:
29662 return NULL;
29663 }
29664
29665
29666 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29667 PyObject *resultobj;
29668 wxWindow *arg1 = (wxWindow *) 0 ;
29669 wxFont *arg2 = 0 ;
29670 PyObject * obj0 = 0 ;
29671 PyObject * obj1 = 0 ;
29672 char *kwnames[] = {
29673 (char *) "self",(char *) "font", NULL
29674 };
29675
29676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29678 if (SWIG_arg_fail(1)) SWIG_fail;
29679 {
29680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29681 if (SWIG_arg_fail(2)) SWIG_fail;
29682 if (arg2 == NULL) {
29683 SWIG_null_ref("wxFont");
29684 }
29685 if (SWIG_arg_fail(2)) SWIG_fail;
29686 }
29687 {
29688 PyThreadState* __tstate = wxPyBeginAllowThreads();
29689 (arg1)->SetOwnFont((wxFont const &)*arg2);
29690
29691 wxPyEndAllowThreads(__tstate);
29692 if (PyErr_Occurred()) SWIG_fail;
29693 }
29694 Py_INCREF(Py_None); resultobj = Py_None;
29695 return resultobj;
29696 fail:
29697 return NULL;
29698 }
29699
29700
29701 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29702 PyObject *resultobj;
29703 wxWindow *arg1 = (wxWindow *) 0 ;
29704 wxFont result;
29705 PyObject * obj0 = 0 ;
29706 char *kwnames[] = {
29707 (char *) "self", NULL
29708 };
29709
29710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29712 if (SWIG_arg_fail(1)) SWIG_fail;
29713 {
29714 PyThreadState* __tstate = wxPyBeginAllowThreads();
29715 result = (arg1)->GetFont();
29716
29717 wxPyEndAllowThreads(__tstate);
29718 if (PyErr_Occurred()) SWIG_fail;
29719 }
29720 {
29721 wxFont * resultptr;
29722 resultptr = new wxFont((wxFont &)(result));
29723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29724 }
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj;
29733 wxWindow *arg1 = (wxWindow *) 0 ;
29734 wxCaret *arg2 = (wxCaret *) 0 ;
29735 PyObject * obj0 = 0 ;
29736 PyObject * obj1 = 0 ;
29737 char *kwnames[] = {
29738 (char *) "self",(char *) "caret", NULL
29739 };
29740
29741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29743 if (SWIG_arg_fail(1)) SWIG_fail;
29744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29745 if (SWIG_arg_fail(2)) SWIG_fail;
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 (arg1)->SetCaret(arg2);
29749
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 Py_INCREF(Py_None); resultobj = Py_None;
29754 return resultobj;
29755 fail:
29756 return NULL;
29757 }
29758
29759
29760 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29761 PyObject *resultobj;
29762 wxWindow *arg1 = (wxWindow *) 0 ;
29763 wxCaret *result;
29764 PyObject * obj0 = 0 ;
29765 char *kwnames[] = {
29766 (char *) "self", NULL
29767 };
29768
29769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29771 if (SWIG_arg_fail(1)) SWIG_fail;
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29775
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29787 PyObject *resultobj;
29788 wxWindow *arg1 = (wxWindow *) 0 ;
29789 int result;
29790 PyObject * obj0 = 0 ;
29791 char *kwnames[] = {
29792 (char *) "self", NULL
29793 };
29794
29795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29800 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29801
29802 wxPyEndAllowThreads(__tstate);
29803 if (PyErr_Occurred()) SWIG_fail;
29804 }
29805 {
29806 resultobj = SWIG_From_int((int)(result));
29807 }
29808 return resultobj;
29809 fail:
29810 return NULL;
29811 }
29812
29813
29814 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29815 PyObject *resultobj;
29816 wxWindow *arg1 = (wxWindow *) 0 ;
29817 int result;
29818 PyObject * obj0 = 0 ;
29819 char *kwnames[] = {
29820 (char *) "self", NULL
29821 };
29822
29823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29825 if (SWIG_arg_fail(1)) SWIG_fail;
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29829
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 {
29834 resultobj = SWIG_From_int((int)(result));
29835 }
29836 return resultobj;
29837 fail:
29838 return NULL;
29839 }
29840
29841
29842 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29843 PyObject *resultobj;
29844 wxWindow *arg1 = (wxWindow *) 0 ;
29845 wxString *arg2 = 0 ;
29846 int *arg3 = (int *) 0 ;
29847 int *arg4 = (int *) 0 ;
29848 bool temp2 = false ;
29849 int temp3 ;
29850 int res3 = 0 ;
29851 int temp4 ;
29852 int res4 = 0 ;
29853 PyObject * obj0 = 0 ;
29854 PyObject * obj1 = 0 ;
29855 char *kwnames[] = {
29856 (char *) "self",(char *) "string", NULL
29857 };
29858
29859 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29860 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29863 if (SWIG_arg_fail(1)) SWIG_fail;
29864 {
29865 arg2 = wxString_in_helper(obj1);
29866 if (arg2 == NULL) SWIG_fail;
29867 temp2 = true;
29868 }
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29872
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 Py_INCREF(Py_None); resultobj = Py_None;
29877 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29878 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29879 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29880 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29881 {
29882 if (temp2)
29883 delete arg2;
29884 }
29885 return resultobj;
29886 fail:
29887 {
29888 if (temp2)
29889 delete arg2;
29890 }
29891 return NULL;
29892 }
29893
29894
29895 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29896 PyObject *resultobj;
29897 wxWindow *arg1 = (wxWindow *) 0 ;
29898 wxString *arg2 = 0 ;
29899 int *arg3 = (int *) 0 ;
29900 int *arg4 = (int *) 0 ;
29901 int *arg5 = (int *) 0 ;
29902 int *arg6 = (int *) 0 ;
29903 wxFont *arg7 = (wxFont *) NULL ;
29904 bool temp2 = false ;
29905 int temp3 ;
29906 int res3 = 0 ;
29907 int temp4 ;
29908 int res4 = 0 ;
29909 int temp5 ;
29910 int res5 = 0 ;
29911 int temp6 ;
29912 int res6 = 0 ;
29913 PyObject * obj0 = 0 ;
29914 PyObject * obj1 = 0 ;
29915 PyObject * obj2 = 0 ;
29916 char *kwnames[] = {
29917 (char *) "self",(char *) "string",(char *) "font", NULL
29918 };
29919
29920 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29921 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29922 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29923 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29926 if (SWIG_arg_fail(1)) SWIG_fail;
29927 {
29928 arg2 = wxString_in_helper(obj1);
29929 if (arg2 == NULL) SWIG_fail;
29930 temp2 = true;
29931 }
29932 if (obj2) {
29933 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29934 if (SWIG_arg_fail(7)) SWIG_fail;
29935 }
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29939
29940 wxPyEndAllowThreads(__tstate);
29941 if (PyErr_Occurred()) SWIG_fail;
29942 }
29943 Py_INCREF(Py_None); resultobj = Py_None;
29944 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29945 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29946 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29947 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29948 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29949 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29950 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29951 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29952 {
29953 if (temp2)
29954 delete arg2;
29955 }
29956 return resultobj;
29957 fail:
29958 {
29959 if (temp2)
29960 delete arg2;
29961 }
29962 return NULL;
29963 }
29964
29965
29966 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj;
29968 wxWindow *arg1 = (wxWindow *) 0 ;
29969 int *arg2 = (int *) 0 ;
29970 int *arg3 = (int *) 0 ;
29971 int temp2 ;
29972 int res2 = 0 ;
29973 int temp3 ;
29974 int res3 = 0 ;
29975 PyObject * obj0 = 0 ;
29976 PyObject * obj1 = 0 ;
29977 PyObject * obj2 = 0 ;
29978 char *kwnames[] = {
29979 (char *) "self",(char *) "x",(char *) "y", NULL
29980 };
29981
29982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29984 if (SWIG_arg_fail(1)) SWIG_fail;
29985 {
29986 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29987 temp2 = SWIG_As_int(obj1);
29988 if (SWIG_arg_fail(2)) SWIG_fail;
29989 arg2 = &temp2;
29990 res2 = SWIG_NEWOBJ;
29991 }
29992 }
29993 {
29994 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29995 temp3 = SWIG_As_int(obj2);
29996 if (SWIG_arg_fail(3)) SWIG_fail;
29997 arg3 = &temp3;
29998 res3 = SWIG_NEWOBJ;
29999 }
30000 }
30001 {
30002 PyThreadState* __tstate = wxPyBeginAllowThreads();
30003 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30004
30005 wxPyEndAllowThreads(__tstate);
30006 if (PyErr_Occurred()) SWIG_fail;
30007 }
30008 Py_INCREF(Py_None); resultobj = Py_None;
30009 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30010 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30011 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30012 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj;
30021 wxWindow *arg1 = (wxWindow *) 0 ;
30022 int *arg2 = (int *) 0 ;
30023 int *arg3 = (int *) 0 ;
30024 int temp2 ;
30025 int res2 = 0 ;
30026 int temp3 ;
30027 int res3 = 0 ;
30028 PyObject * obj0 = 0 ;
30029 PyObject * obj1 = 0 ;
30030 PyObject * obj2 = 0 ;
30031 char *kwnames[] = {
30032 (char *) "self",(char *) "x",(char *) "y", NULL
30033 };
30034
30035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30037 if (SWIG_arg_fail(1)) SWIG_fail;
30038 {
30039 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30040 temp2 = SWIG_As_int(obj1);
30041 if (SWIG_arg_fail(2)) SWIG_fail;
30042 arg2 = &temp2;
30043 res2 = SWIG_NEWOBJ;
30044 }
30045 }
30046 {
30047 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30048 temp3 = SWIG_As_int(obj2);
30049 if (SWIG_arg_fail(3)) SWIG_fail;
30050 arg3 = &temp3;
30051 res3 = SWIG_NEWOBJ;
30052 }
30053 }
30054 {
30055 PyThreadState* __tstate = wxPyBeginAllowThreads();
30056 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30057
30058 wxPyEndAllowThreads(__tstate);
30059 if (PyErr_Occurred()) SWIG_fail;
30060 }
30061 Py_INCREF(Py_None); resultobj = Py_None;
30062 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30063 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30064 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30065 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30066 return resultobj;
30067 fail:
30068 return NULL;
30069 }
30070
30071
30072 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30073 PyObject *resultobj;
30074 wxWindow *arg1 = (wxWindow *) 0 ;
30075 wxPoint *arg2 = 0 ;
30076 wxPoint result;
30077 wxPoint temp2 ;
30078 PyObject * obj0 = 0 ;
30079 PyObject * obj1 = 0 ;
30080 char *kwnames[] = {
30081 (char *) "self",(char *) "pt", NULL
30082 };
30083
30084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30086 if (SWIG_arg_fail(1)) SWIG_fail;
30087 {
30088 arg2 = &temp2;
30089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30090 }
30091 {
30092 PyThreadState* __tstate = wxPyBeginAllowThreads();
30093 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30094
30095 wxPyEndAllowThreads(__tstate);
30096 if (PyErr_Occurred()) SWIG_fail;
30097 }
30098 {
30099 wxPoint * resultptr;
30100 resultptr = new wxPoint((wxPoint &)(result));
30101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30102 }
30103 return resultobj;
30104 fail:
30105 return NULL;
30106 }
30107
30108
30109 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30110 PyObject *resultobj;
30111 wxWindow *arg1 = (wxWindow *) 0 ;
30112 wxPoint *arg2 = 0 ;
30113 wxPoint result;
30114 wxPoint temp2 ;
30115 PyObject * obj0 = 0 ;
30116 PyObject * obj1 = 0 ;
30117 char *kwnames[] = {
30118 (char *) "self",(char *) "pt", NULL
30119 };
30120
30121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30123 if (SWIG_arg_fail(1)) SWIG_fail;
30124 {
30125 arg2 = &temp2;
30126 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30127 }
30128 {
30129 PyThreadState* __tstate = wxPyBeginAllowThreads();
30130 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30131
30132 wxPyEndAllowThreads(__tstate);
30133 if (PyErr_Occurred()) SWIG_fail;
30134 }
30135 {
30136 wxPoint * resultptr;
30137 resultptr = new wxPoint((wxPoint &)(result));
30138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30139 }
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj;
30148 wxWindow *arg1 = (wxWindow *) 0 ;
30149 int arg2 ;
30150 int arg3 ;
30151 wxHitTest result;
30152 PyObject * obj0 = 0 ;
30153 PyObject * obj1 = 0 ;
30154 PyObject * obj2 = 0 ;
30155 char *kwnames[] = {
30156 (char *) "self",(char *) "x",(char *) "y", NULL
30157 };
30158
30159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30161 if (SWIG_arg_fail(1)) SWIG_fail;
30162 {
30163 arg2 = (int)(SWIG_As_int(obj1));
30164 if (SWIG_arg_fail(2)) SWIG_fail;
30165 }
30166 {
30167 arg3 = (int)(SWIG_As_int(obj2));
30168 if (SWIG_arg_fail(3)) SWIG_fail;
30169 }
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30173
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 resultobj = SWIG_From_int((result));
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30185 PyObject *resultobj;
30186 wxWindow *arg1 = (wxWindow *) 0 ;
30187 wxPoint *arg2 = 0 ;
30188 wxHitTest result;
30189 wxPoint temp2 ;
30190 PyObject * obj0 = 0 ;
30191 PyObject * obj1 = 0 ;
30192 char *kwnames[] = {
30193 (char *) "self",(char *) "pt", NULL
30194 };
30195
30196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30198 if (SWIG_arg_fail(1)) SWIG_fail;
30199 {
30200 arg2 = &temp2;
30201 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30202 }
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30206
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 resultobj = SWIG_From_int((result));
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30218 PyObject *resultobj;
30219 wxWindow *arg1 = (wxWindow *) 0 ;
30220 long arg2 ;
30221 wxBorder result;
30222 PyObject * obj0 = 0 ;
30223 PyObject * obj1 = 0 ;
30224
30225 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30227 if (SWIG_arg_fail(1)) SWIG_fail;
30228 {
30229 arg2 = (long)(SWIG_As_long(obj1));
30230 if (SWIG_arg_fail(2)) SWIG_fail;
30231 }
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30235
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 resultobj = SWIG_From_int((result));
30240 return resultobj;
30241 fail:
30242 return NULL;
30243 }
30244
30245
30246 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30247 PyObject *resultobj;
30248 wxWindow *arg1 = (wxWindow *) 0 ;
30249 wxBorder result;
30250 PyObject * obj0 = 0 ;
30251
30252 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30254 if (SWIG_arg_fail(1)) SWIG_fail;
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30258
30259 wxPyEndAllowThreads(__tstate);
30260 if (PyErr_Occurred()) SWIG_fail;
30261 }
30262 resultobj = SWIG_From_int((result));
30263 return resultobj;
30264 fail:
30265 return NULL;
30266 }
30267
30268
30269 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30270 int argc;
30271 PyObject *argv[3];
30272 int ii;
30273
30274 argc = PyObject_Length(args);
30275 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30276 argv[ii] = PyTuple_GetItem(args,ii);
30277 }
30278 if (argc == 1) {
30279 int _v;
30280 {
30281 void *ptr;
30282 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30283 _v = 0;
30284 PyErr_Clear();
30285 } else {
30286 _v = 1;
30287 }
30288 }
30289 if (_v) {
30290 return _wrap_Window_GetBorder__SWIG_1(self,args);
30291 }
30292 }
30293 if (argc == 2) {
30294 int _v;
30295 {
30296 void *ptr;
30297 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30298 _v = 0;
30299 PyErr_Clear();
30300 } else {
30301 _v = 1;
30302 }
30303 }
30304 if (_v) {
30305 _v = SWIG_Check_long(argv[1]);
30306 if (_v) {
30307 return _wrap_Window_GetBorder__SWIG_0(self,args);
30308 }
30309 }
30310 }
30311
30312 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30313 return NULL;
30314 }
30315
30316
30317 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30318 PyObject *resultobj;
30319 wxWindow *arg1 = (wxWindow *) 0 ;
30320 long arg2 = (long) wxUPDATE_UI_NONE ;
30321 PyObject * obj0 = 0 ;
30322 PyObject * obj1 = 0 ;
30323 char *kwnames[] = {
30324 (char *) "self",(char *) "flags", NULL
30325 };
30326
30327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30329 if (SWIG_arg_fail(1)) SWIG_fail;
30330 if (obj1) {
30331 {
30332 arg2 = (long)(SWIG_As_long(obj1));
30333 if (SWIG_arg_fail(2)) SWIG_fail;
30334 }
30335 }
30336 {
30337 PyThreadState* __tstate = wxPyBeginAllowThreads();
30338 (arg1)->UpdateWindowUI(arg2);
30339
30340 wxPyEndAllowThreads(__tstate);
30341 if (PyErr_Occurred()) SWIG_fail;
30342 }
30343 Py_INCREF(Py_None); resultobj = Py_None;
30344 return resultobj;
30345 fail:
30346 return NULL;
30347 }
30348
30349
30350 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30351 PyObject *resultobj;
30352 wxWindow *arg1 = (wxWindow *) 0 ;
30353 wxMenu *arg2 = (wxMenu *) 0 ;
30354 int arg3 = (int) -1 ;
30355 int arg4 = (int) -1 ;
30356 bool result;
30357 PyObject * obj0 = 0 ;
30358 PyObject * obj1 = 0 ;
30359 PyObject * obj2 = 0 ;
30360 PyObject * obj3 = 0 ;
30361 char *kwnames[] = {
30362 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30363 };
30364
30365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30367 if (SWIG_arg_fail(1)) SWIG_fail;
30368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30369 if (SWIG_arg_fail(2)) SWIG_fail;
30370 if (obj2) {
30371 {
30372 arg3 = (int)(SWIG_As_int(obj2));
30373 if (SWIG_arg_fail(3)) SWIG_fail;
30374 }
30375 }
30376 if (obj3) {
30377 {
30378 arg4 = (int)(SWIG_As_int(obj3));
30379 if (SWIG_arg_fail(4)) SWIG_fail;
30380 }
30381 }
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30385
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 {
30390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30391 }
30392 return resultobj;
30393 fail:
30394 return NULL;
30395 }
30396
30397
30398 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30399 PyObject *resultobj;
30400 wxWindow *arg1 = (wxWindow *) 0 ;
30401 wxMenu *arg2 = (wxMenu *) 0 ;
30402 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30403 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30404 bool result;
30405 wxPoint temp3 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 PyObject * obj2 = 0 ;
30409 char *kwnames[] = {
30410 (char *) "self",(char *) "menu",(char *) "pos", NULL
30411 };
30412
30413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30415 if (SWIG_arg_fail(1)) SWIG_fail;
30416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30417 if (SWIG_arg_fail(2)) SWIG_fail;
30418 if (obj2) {
30419 {
30420 arg3 = &temp3;
30421 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30422 }
30423 }
30424 {
30425 PyThreadState* __tstate = wxPyBeginAllowThreads();
30426 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30427
30428 wxPyEndAllowThreads(__tstate);
30429 if (PyErr_Occurred()) SWIG_fail;
30430 }
30431 {
30432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30433 }
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj;
30442 wxWindow *arg1 = (wxWindow *) 0 ;
30443 long result;
30444 PyObject * obj0 = 0 ;
30445 char *kwnames[] = {
30446 (char *) "self", NULL
30447 };
30448
30449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 {
30453 PyThreadState* __tstate = wxPyBeginAllowThreads();
30454 result = (long)wxWindow_GetHandle(arg1);
30455
30456 wxPyEndAllowThreads(__tstate);
30457 if (PyErr_Occurred()) SWIG_fail;
30458 }
30459 {
30460 resultobj = SWIG_From_long((long)(result));
30461 }
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30469 PyObject *resultobj;
30470 wxWindow *arg1 = (wxWindow *) 0 ;
30471 long arg2 ;
30472 PyObject * obj0 = 0 ;
30473 PyObject * obj1 = 0 ;
30474 char *kwnames[] = {
30475 (char *) "self",(char *) "handle", NULL
30476 };
30477
30478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30480 if (SWIG_arg_fail(1)) SWIG_fail;
30481 {
30482 arg2 = (long)(SWIG_As_long(obj1));
30483 if (SWIG_arg_fail(2)) SWIG_fail;
30484 }
30485 {
30486 PyThreadState* __tstate = wxPyBeginAllowThreads();
30487 wxWindow_AssociateHandle(arg1,arg2);
30488
30489 wxPyEndAllowThreads(__tstate);
30490 if (PyErr_Occurred()) SWIG_fail;
30491 }
30492 Py_INCREF(Py_None); resultobj = Py_None;
30493 return resultobj;
30494 fail:
30495 return NULL;
30496 }
30497
30498
30499 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30500 PyObject *resultobj;
30501 wxWindow *arg1 = (wxWindow *) 0 ;
30502 PyObject * obj0 = 0 ;
30503 char *kwnames[] = {
30504 (char *) "self", NULL
30505 };
30506
30507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30509 if (SWIG_arg_fail(1)) SWIG_fail;
30510 {
30511 PyThreadState* __tstate = wxPyBeginAllowThreads();
30512 (arg1)->DissociateHandle();
30513
30514 wxPyEndAllowThreads(__tstate);
30515 if (PyErr_Occurred()) SWIG_fail;
30516 }
30517 Py_INCREF(Py_None); resultobj = Py_None;
30518 return resultobj;
30519 fail:
30520 return NULL;
30521 }
30522
30523
30524 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30525 PyObject *resultobj;
30526 wxWindow *arg1 = (wxWindow *) 0 ;
30527 wxPaintEvent *arg2 = 0 ;
30528 PyObject * obj0 = 0 ;
30529 PyObject * obj1 = 0 ;
30530 char *kwnames[] = {
30531 (char *) "self",(char *) "event", NULL
30532 };
30533
30534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30536 if (SWIG_arg_fail(1)) SWIG_fail;
30537 {
30538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30539 if (SWIG_arg_fail(2)) SWIG_fail;
30540 if (arg2 == NULL) {
30541 SWIG_null_ref("wxPaintEvent");
30542 }
30543 if (SWIG_arg_fail(2)) SWIG_fail;
30544 }
30545 {
30546 PyThreadState* __tstate = wxPyBeginAllowThreads();
30547 (arg1)->OnPaint(*arg2);
30548
30549 wxPyEndAllowThreads(__tstate);
30550 if (PyErr_Occurred()) SWIG_fail;
30551 }
30552 Py_INCREF(Py_None); resultobj = Py_None;
30553 return resultobj;
30554 fail:
30555 return NULL;
30556 }
30557
30558
30559 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30560 PyObject *resultobj;
30561 wxWindow *arg1 = (wxWindow *) 0 ;
30562 int arg2 ;
30563 bool result;
30564 PyObject * obj0 = 0 ;
30565 PyObject * obj1 = 0 ;
30566 char *kwnames[] = {
30567 (char *) "self",(char *) "orient", NULL
30568 };
30569
30570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30572 if (SWIG_arg_fail(1)) SWIG_fail;
30573 {
30574 arg2 = (int)(SWIG_As_int(obj1));
30575 if (SWIG_arg_fail(2)) SWIG_fail;
30576 }
30577 {
30578 PyThreadState* __tstate = wxPyBeginAllowThreads();
30579 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30580
30581 wxPyEndAllowThreads(__tstate);
30582 if (PyErr_Occurred()) SWIG_fail;
30583 }
30584 {
30585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30586 }
30587 return resultobj;
30588 fail:
30589 return NULL;
30590 }
30591
30592
30593 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30594 PyObject *resultobj;
30595 wxWindow *arg1 = (wxWindow *) 0 ;
30596 int arg2 ;
30597 int arg3 ;
30598 int arg4 ;
30599 int arg5 ;
30600 bool arg6 = (bool) true ;
30601 PyObject * obj0 = 0 ;
30602 PyObject * obj1 = 0 ;
30603 PyObject * obj2 = 0 ;
30604 PyObject * obj3 = 0 ;
30605 PyObject * obj4 = 0 ;
30606 PyObject * obj5 = 0 ;
30607 char *kwnames[] = {
30608 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30609 };
30610
30611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 = (int)(SWIG_As_int(obj1));
30616 if (SWIG_arg_fail(2)) SWIG_fail;
30617 }
30618 {
30619 arg3 = (int)(SWIG_As_int(obj2));
30620 if (SWIG_arg_fail(3)) SWIG_fail;
30621 }
30622 {
30623 arg4 = (int)(SWIG_As_int(obj3));
30624 if (SWIG_arg_fail(4)) SWIG_fail;
30625 }
30626 {
30627 arg5 = (int)(SWIG_As_int(obj4));
30628 if (SWIG_arg_fail(5)) SWIG_fail;
30629 }
30630 if (obj5) {
30631 {
30632 arg6 = (bool)(SWIG_As_bool(obj5));
30633 if (SWIG_arg_fail(6)) SWIG_fail;
30634 }
30635 }
30636 {
30637 PyThreadState* __tstate = wxPyBeginAllowThreads();
30638 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30639
30640 wxPyEndAllowThreads(__tstate);
30641 if (PyErr_Occurred()) SWIG_fail;
30642 }
30643 Py_INCREF(Py_None); resultobj = Py_None;
30644 return resultobj;
30645 fail:
30646 return NULL;
30647 }
30648
30649
30650 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30651 PyObject *resultobj;
30652 wxWindow *arg1 = (wxWindow *) 0 ;
30653 int arg2 ;
30654 int arg3 ;
30655 bool arg4 = (bool) true ;
30656 PyObject * obj0 = 0 ;
30657 PyObject * obj1 = 0 ;
30658 PyObject * obj2 = 0 ;
30659 PyObject * obj3 = 0 ;
30660 char *kwnames[] = {
30661 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30662 };
30663
30664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30666 if (SWIG_arg_fail(1)) SWIG_fail;
30667 {
30668 arg2 = (int)(SWIG_As_int(obj1));
30669 if (SWIG_arg_fail(2)) SWIG_fail;
30670 }
30671 {
30672 arg3 = (int)(SWIG_As_int(obj2));
30673 if (SWIG_arg_fail(3)) SWIG_fail;
30674 }
30675 if (obj3) {
30676 {
30677 arg4 = (bool)(SWIG_As_bool(obj3));
30678 if (SWIG_arg_fail(4)) SWIG_fail;
30679 }
30680 }
30681 {
30682 PyThreadState* __tstate = wxPyBeginAllowThreads();
30683 (arg1)->SetScrollPos(arg2,arg3,arg4);
30684
30685 wxPyEndAllowThreads(__tstate);
30686 if (PyErr_Occurred()) SWIG_fail;
30687 }
30688 Py_INCREF(Py_None); resultobj = Py_None;
30689 return resultobj;
30690 fail:
30691 return NULL;
30692 }
30693
30694
30695 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30696 PyObject *resultobj;
30697 wxWindow *arg1 = (wxWindow *) 0 ;
30698 int arg2 ;
30699 int result;
30700 PyObject * obj0 = 0 ;
30701 PyObject * obj1 = 0 ;
30702 char *kwnames[] = {
30703 (char *) "self",(char *) "orientation", NULL
30704 };
30705
30706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30708 if (SWIG_arg_fail(1)) SWIG_fail;
30709 {
30710 arg2 = (int)(SWIG_As_int(obj1));
30711 if (SWIG_arg_fail(2)) SWIG_fail;
30712 }
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30716
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 {
30721 resultobj = SWIG_From_int((int)(result));
30722 }
30723 return resultobj;
30724 fail:
30725 return NULL;
30726 }
30727
30728
30729 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30730 PyObject *resultobj;
30731 wxWindow *arg1 = (wxWindow *) 0 ;
30732 int arg2 ;
30733 int result;
30734 PyObject * obj0 = 0 ;
30735 PyObject * obj1 = 0 ;
30736 char *kwnames[] = {
30737 (char *) "self",(char *) "orientation", NULL
30738 };
30739
30740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30742 if (SWIG_arg_fail(1)) SWIG_fail;
30743 {
30744 arg2 = (int)(SWIG_As_int(obj1));
30745 if (SWIG_arg_fail(2)) SWIG_fail;
30746 }
30747 {
30748 PyThreadState* __tstate = wxPyBeginAllowThreads();
30749 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30750
30751 wxPyEndAllowThreads(__tstate);
30752 if (PyErr_Occurred()) SWIG_fail;
30753 }
30754 {
30755 resultobj = SWIG_From_int((int)(result));
30756 }
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30764 PyObject *resultobj;
30765 wxWindow *arg1 = (wxWindow *) 0 ;
30766 int arg2 ;
30767 int result;
30768 PyObject * obj0 = 0 ;
30769 PyObject * obj1 = 0 ;
30770 char *kwnames[] = {
30771 (char *) "self",(char *) "orientation", NULL
30772 };
30773
30774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30776 if (SWIG_arg_fail(1)) SWIG_fail;
30777 {
30778 arg2 = (int)(SWIG_As_int(obj1));
30779 if (SWIG_arg_fail(2)) SWIG_fail;
30780 }
30781 {
30782 PyThreadState* __tstate = wxPyBeginAllowThreads();
30783 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30784
30785 wxPyEndAllowThreads(__tstate);
30786 if (PyErr_Occurred()) SWIG_fail;
30787 }
30788 {
30789 resultobj = SWIG_From_int((int)(result));
30790 }
30791 return resultobj;
30792 fail:
30793 return NULL;
30794 }
30795
30796
30797 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30798 PyObject *resultobj;
30799 wxWindow *arg1 = (wxWindow *) 0 ;
30800 int arg2 ;
30801 int arg3 ;
30802 wxRect *arg4 = (wxRect *) NULL ;
30803 PyObject * obj0 = 0 ;
30804 PyObject * obj1 = 0 ;
30805 PyObject * obj2 = 0 ;
30806 PyObject * obj3 = 0 ;
30807 char *kwnames[] = {
30808 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30809 };
30810
30811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30813 if (SWIG_arg_fail(1)) SWIG_fail;
30814 {
30815 arg2 = (int)(SWIG_As_int(obj1));
30816 if (SWIG_arg_fail(2)) SWIG_fail;
30817 }
30818 {
30819 arg3 = (int)(SWIG_As_int(obj2));
30820 if (SWIG_arg_fail(3)) SWIG_fail;
30821 }
30822 if (obj3) {
30823 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30824 if (SWIG_arg_fail(4)) SWIG_fail;
30825 }
30826 {
30827 PyThreadState* __tstate = wxPyBeginAllowThreads();
30828 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30829
30830 wxPyEndAllowThreads(__tstate);
30831 if (PyErr_Occurred()) SWIG_fail;
30832 }
30833 Py_INCREF(Py_None); resultobj = Py_None;
30834 return resultobj;
30835 fail:
30836 return NULL;
30837 }
30838
30839
30840 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30841 PyObject *resultobj;
30842 wxWindow *arg1 = (wxWindow *) 0 ;
30843 int arg2 ;
30844 bool result;
30845 PyObject * obj0 = 0 ;
30846 PyObject * obj1 = 0 ;
30847 char *kwnames[] = {
30848 (char *) "self",(char *) "lines", NULL
30849 };
30850
30851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30853 if (SWIG_arg_fail(1)) SWIG_fail;
30854 {
30855 arg2 = (int)(SWIG_As_int(obj1));
30856 if (SWIG_arg_fail(2)) SWIG_fail;
30857 }
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 result = (bool)(arg1)->ScrollLines(arg2);
30861
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 {
30866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30867 }
30868 return resultobj;
30869 fail:
30870 return NULL;
30871 }
30872
30873
30874 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj;
30876 wxWindow *arg1 = (wxWindow *) 0 ;
30877 int arg2 ;
30878 bool result;
30879 PyObject * obj0 = 0 ;
30880 PyObject * obj1 = 0 ;
30881 char *kwnames[] = {
30882 (char *) "self",(char *) "pages", NULL
30883 };
30884
30885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30887 if (SWIG_arg_fail(1)) SWIG_fail;
30888 {
30889 arg2 = (int)(SWIG_As_int(obj1));
30890 if (SWIG_arg_fail(2)) SWIG_fail;
30891 }
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 result = (bool)(arg1)->ScrollPages(arg2);
30895
30896 wxPyEndAllowThreads(__tstate);
30897 if (PyErr_Occurred()) SWIG_fail;
30898 }
30899 {
30900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30901 }
30902 return resultobj;
30903 fail:
30904 return NULL;
30905 }
30906
30907
30908 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30909 PyObject *resultobj;
30910 wxWindow *arg1 = (wxWindow *) 0 ;
30911 bool result;
30912 PyObject * obj0 = 0 ;
30913 char *kwnames[] = {
30914 (char *) "self", NULL
30915 };
30916
30917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30919 if (SWIG_arg_fail(1)) SWIG_fail;
30920 {
30921 PyThreadState* __tstate = wxPyBeginAllowThreads();
30922 result = (bool)(arg1)->LineUp();
30923
30924 wxPyEndAllowThreads(__tstate);
30925 if (PyErr_Occurred()) SWIG_fail;
30926 }
30927 {
30928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30929 }
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj;
30938 wxWindow *arg1 = (wxWindow *) 0 ;
30939 bool result;
30940 PyObject * obj0 = 0 ;
30941 char *kwnames[] = {
30942 (char *) "self", NULL
30943 };
30944
30945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30947 if (SWIG_arg_fail(1)) SWIG_fail;
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 result = (bool)(arg1)->LineDown();
30951
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 {
30956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30957 }
30958 return resultobj;
30959 fail:
30960 return NULL;
30961 }
30962
30963
30964 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj;
30966 wxWindow *arg1 = (wxWindow *) 0 ;
30967 bool result;
30968 PyObject * obj0 = 0 ;
30969 char *kwnames[] = {
30970 (char *) "self", NULL
30971 };
30972
30973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30975 if (SWIG_arg_fail(1)) SWIG_fail;
30976 {
30977 PyThreadState* __tstate = wxPyBeginAllowThreads();
30978 result = (bool)(arg1)->PageUp();
30979
30980 wxPyEndAllowThreads(__tstate);
30981 if (PyErr_Occurred()) SWIG_fail;
30982 }
30983 {
30984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30985 }
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30993 PyObject *resultobj;
30994 wxWindow *arg1 = (wxWindow *) 0 ;
30995 bool result;
30996 PyObject * obj0 = 0 ;
30997 char *kwnames[] = {
30998 (char *) "self", NULL
30999 };
31000
31001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31003 if (SWIG_arg_fail(1)) SWIG_fail;
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 result = (bool)(arg1)->PageDown();
31007
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 {
31012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31013 }
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj;
31022 wxWindow *arg1 = (wxWindow *) 0 ;
31023 wxString *arg2 = 0 ;
31024 bool temp2 = false ;
31025 PyObject * obj0 = 0 ;
31026 PyObject * obj1 = 0 ;
31027 char *kwnames[] = {
31028 (char *) "self",(char *) "text", NULL
31029 };
31030
31031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31033 if (SWIG_arg_fail(1)) SWIG_fail;
31034 {
31035 arg2 = wxString_in_helper(obj1);
31036 if (arg2 == NULL) SWIG_fail;
31037 temp2 = true;
31038 }
31039 {
31040 PyThreadState* __tstate = wxPyBeginAllowThreads();
31041 (arg1)->SetHelpText((wxString const &)*arg2);
31042
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 Py_INCREF(Py_None); resultobj = Py_None;
31047 {
31048 if (temp2)
31049 delete arg2;
31050 }
31051 return resultobj;
31052 fail:
31053 {
31054 if (temp2)
31055 delete arg2;
31056 }
31057 return NULL;
31058 }
31059
31060
31061 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31062 PyObject *resultobj;
31063 wxWindow *arg1 = (wxWindow *) 0 ;
31064 wxString *arg2 = 0 ;
31065 bool temp2 = false ;
31066 PyObject * obj0 = 0 ;
31067 PyObject * obj1 = 0 ;
31068 char *kwnames[] = {
31069 (char *) "self",(char *) "text", NULL
31070 };
31071
31072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31074 if (SWIG_arg_fail(1)) SWIG_fail;
31075 {
31076 arg2 = wxString_in_helper(obj1);
31077 if (arg2 == NULL) SWIG_fail;
31078 temp2 = true;
31079 }
31080 {
31081 PyThreadState* __tstate = wxPyBeginAllowThreads();
31082 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31083
31084 wxPyEndAllowThreads(__tstate);
31085 if (PyErr_Occurred()) SWIG_fail;
31086 }
31087 Py_INCREF(Py_None); resultobj = Py_None;
31088 {
31089 if (temp2)
31090 delete arg2;
31091 }
31092 return resultobj;
31093 fail:
31094 {
31095 if (temp2)
31096 delete arg2;
31097 }
31098 return NULL;
31099 }
31100
31101
31102 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31103 PyObject *resultobj;
31104 wxWindow *arg1 = (wxWindow *) 0 ;
31105 wxString result;
31106 PyObject * obj0 = 0 ;
31107 char *kwnames[] = {
31108 (char *) "self", NULL
31109 };
31110
31111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31113 if (SWIG_arg_fail(1)) SWIG_fail;
31114 {
31115 PyThreadState* __tstate = wxPyBeginAllowThreads();
31116 result = ((wxWindow const *)arg1)->GetHelpText();
31117
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 {
31122 #if wxUSE_UNICODE
31123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31124 #else
31125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31126 #endif
31127 }
31128 return resultobj;
31129 fail:
31130 return NULL;
31131 }
31132
31133
31134 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31135 PyObject *resultobj;
31136 wxWindow *arg1 = (wxWindow *) 0 ;
31137 wxString *arg2 = 0 ;
31138 bool temp2 = false ;
31139 PyObject * obj0 = 0 ;
31140 PyObject * obj1 = 0 ;
31141 char *kwnames[] = {
31142 (char *) "self",(char *) "tip", NULL
31143 };
31144
31145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31147 if (SWIG_arg_fail(1)) SWIG_fail;
31148 {
31149 arg2 = wxString_in_helper(obj1);
31150 if (arg2 == NULL) SWIG_fail;
31151 temp2 = true;
31152 }
31153 {
31154 PyThreadState* __tstate = wxPyBeginAllowThreads();
31155 (arg1)->SetToolTip((wxString const &)*arg2);
31156
31157 wxPyEndAllowThreads(__tstate);
31158 if (PyErr_Occurred()) SWIG_fail;
31159 }
31160 Py_INCREF(Py_None); resultobj = Py_None;
31161 {
31162 if (temp2)
31163 delete arg2;
31164 }
31165 return resultobj;
31166 fail:
31167 {
31168 if (temp2)
31169 delete arg2;
31170 }
31171 return NULL;
31172 }
31173
31174
31175 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31176 PyObject *resultobj;
31177 wxWindow *arg1 = (wxWindow *) 0 ;
31178 wxToolTip *arg2 = (wxToolTip *) 0 ;
31179 PyObject * obj0 = 0 ;
31180 PyObject * obj1 = 0 ;
31181 char *kwnames[] = {
31182 (char *) "self",(char *) "tip", NULL
31183 };
31184
31185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31187 if (SWIG_arg_fail(1)) SWIG_fail;
31188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31189 if (SWIG_arg_fail(2)) SWIG_fail;
31190 {
31191 PyThreadState* __tstate = wxPyBeginAllowThreads();
31192 (arg1)->SetToolTip(arg2);
31193
31194 wxPyEndAllowThreads(__tstate);
31195 if (PyErr_Occurred()) SWIG_fail;
31196 }
31197 Py_INCREF(Py_None); resultobj = Py_None;
31198 return resultobj;
31199 fail:
31200 return NULL;
31201 }
31202
31203
31204 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31205 PyObject *resultobj;
31206 wxWindow *arg1 = (wxWindow *) 0 ;
31207 wxToolTip *result;
31208 PyObject * obj0 = 0 ;
31209 char *kwnames[] = {
31210 (char *) "self", NULL
31211 };
31212
31213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31215 if (SWIG_arg_fail(1)) SWIG_fail;
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31219
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 {
31224 resultobj = wxPyMake_wxObject(result, 0);
31225 }
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31233 PyObject *resultobj;
31234 wxWindow *arg1 = (wxWindow *) 0 ;
31235 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31236 PyObject * obj0 = 0 ;
31237 PyObject * obj1 = 0 ;
31238 char *kwnames[] = {
31239 (char *) "self",(char *) "dropTarget", NULL
31240 };
31241
31242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31244 if (SWIG_arg_fail(1)) SWIG_fail;
31245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31246 if (SWIG_arg_fail(2)) SWIG_fail;
31247 {
31248 PyThreadState* __tstate = wxPyBeginAllowThreads();
31249 (arg1)->SetDropTarget(arg2);
31250
31251 wxPyEndAllowThreads(__tstate);
31252 if (PyErr_Occurred()) SWIG_fail;
31253 }
31254 Py_INCREF(Py_None); resultobj = Py_None;
31255 return resultobj;
31256 fail:
31257 return NULL;
31258 }
31259
31260
31261 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31262 PyObject *resultobj;
31263 wxWindow *arg1 = (wxWindow *) 0 ;
31264 wxPyDropTarget *result;
31265 PyObject * obj0 = 0 ;
31266 char *kwnames[] = {
31267 (char *) "self", NULL
31268 };
31269
31270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31272 if (SWIG_arg_fail(1)) SWIG_fail;
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31276
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31288 PyObject *resultobj;
31289 wxWindow *arg1 = (wxWindow *) 0 ;
31290 bool arg2 ;
31291 PyObject * obj0 = 0 ;
31292 PyObject * obj1 = 0 ;
31293 char *kwnames[] = {
31294 (char *) "self",(char *) "accept", NULL
31295 };
31296
31297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31299 if (SWIG_arg_fail(1)) SWIG_fail;
31300 {
31301 arg2 = (bool)(SWIG_As_bool(obj1));
31302 if (SWIG_arg_fail(2)) SWIG_fail;
31303 }
31304 {
31305 PyThreadState* __tstate = wxPyBeginAllowThreads();
31306 (arg1)->DragAcceptFiles(arg2);
31307
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 Py_INCREF(Py_None); resultobj = Py_None;
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31319 PyObject *resultobj;
31320 wxWindow *arg1 = (wxWindow *) 0 ;
31321 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31322 PyObject * obj0 = 0 ;
31323 PyObject * obj1 = 0 ;
31324 char *kwnames[] = {
31325 (char *) "self",(char *) "constraints", NULL
31326 };
31327
31328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31330 if (SWIG_arg_fail(1)) SWIG_fail;
31331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31332 if (SWIG_arg_fail(2)) SWIG_fail;
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 (arg1)->SetConstraints(arg2);
31336
31337 wxPyEndAllowThreads(__tstate);
31338 if (PyErr_Occurred()) SWIG_fail;
31339 }
31340 Py_INCREF(Py_None); resultobj = Py_None;
31341 return resultobj;
31342 fail:
31343 return NULL;
31344 }
31345
31346
31347 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31348 PyObject *resultobj;
31349 wxWindow *arg1 = (wxWindow *) 0 ;
31350 wxLayoutConstraints *result;
31351 PyObject * obj0 = 0 ;
31352 char *kwnames[] = {
31353 (char *) "self", NULL
31354 };
31355
31356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31358 if (SWIG_arg_fail(1)) SWIG_fail;
31359 {
31360 PyThreadState* __tstate = wxPyBeginAllowThreads();
31361 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31362
31363 wxPyEndAllowThreads(__tstate);
31364 if (PyErr_Occurred()) SWIG_fail;
31365 }
31366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31367 return resultobj;
31368 fail:
31369 return NULL;
31370 }
31371
31372
31373 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31374 PyObject *resultobj;
31375 wxWindow *arg1 = (wxWindow *) 0 ;
31376 bool arg2 ;
31377 PyObject * obj0 = 0 ;
31378 PyObject * obj1 = 0 ;
31379 char *kwnames[] = {
31380 (char *) "self",(char *) "autoLayout", NULL
31381 };
31382
31383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31385 if (SWIG_arg_fail(1)) SWIG_fail;
31386 {
31387 arg2 = (bool)(SWIG_As_bool(obj1));
31388 if (SWIG_arg_fail(2)) SWIG_fail;
31389 }
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 (arg1)->SetAutoLayout(arg2);
31393
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 Py_INCREF(Py_None); resultobj = Py_None;
31398 return resultobj;
31399 fail:
31400 return NULL;
31401 }
31402
31403
31404 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31405 PyObject *resultobj;
31406 wxWindow *arg1 = (wxWindow *) 0 ;
31407 bool result;
31408 PyObject * obj0 = 0 ;
31409 char *kwnames[] = {
31410 (char *) "self", NULL
31411 };
31412
31413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31415 if (SWIG_arg_fail(1)) SWIG_fail;
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31419
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 {
31424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31425 }
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31433 PyObject *resultobj;
31434 wxWindow *arg1 = (wxWindow *) 0 ;
31435 bool result;
31436 PyObject * obj0 = 0 ;
31437 char *kwnames[] = {
31438 (char *) "self", NULL
31439 };
31440
31441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31443 if (SWIG_arg_fail(1)) SWIG_fail;
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 result = (bool)(arg1)->Layout();
31447
31448 wxPyEndAllowThreads(__tstate);
31449 if (PyErr_Occurred()) SWIG_fail;
31450 }
31451 {
31452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31453 }
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31461 PyObject *resultobj;
31462 wxWindow *arg1 = (wxWindow *) 0 ;
31463 wxSizer *arg2 = (wxSizer *) 0 ;
31464 bool arg3 = (bool) true ;
31465 PyObject * obj0 = 0 ;
31466 PyObject * obj1 = 0 ;
31467 PyObject * obj2 = 0 ;
31468 char *kwnames[] = {
31469 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31470 };
31471
31472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31474 if (SWIG_arg_fail(1)) SWIG_fail;
31475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31476 if (SWIG_arg_fail(2)) SWIG_fail;
31477 if (obj2) {
31478 {
31479 arg3 = (bool)(SWIG_As_bool(obj2));
31480 if (SWIG_arg_fail(3)) SWIG_fail;
31481 }
31482 }
31483 {
31484 PyThreadState* __tstate = wxPyBeginAllowThreads();
31485 (arg1)->SetSizer(arg2,arg3);
31486
31487 wxPyEndAllowThreads(__tstate);
31488 if (PyErr_Occurred()) SWIG_fail;
31489 }
31490 Py_INCREF(Py_None); resultobj = Py_None;
31491 return resultobj;
31492 fail:
31493 return NULL;
31494 }
31495
31496
31497 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31498 PyObject *resultobj;
31499 wxWindow *arg1 = (wxWindow *) 0 ;
31500 wxSizer *arg2 = (wxSizer *) 0 ;
31501 bool arg3 = (bool) true ;
31502 PyObject * obj0 = 0 ;
31503 PyObject * obj1 = 0 ;
31504 PyObject * obj2 = 0 ;
31505 char *kwnames[] = {
31506 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31507 };
31508
31509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31511 if (SWIG_arg_fail(1)) SWIG_fail;
31512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31513 if (SWIG_arg_fail(2)) SWIG_fail;
31514 if (obj2) {
31515 {
31516 arg3 = (bool)(SWIG_As_bool(obj2));
31517 if (SWIG_arg_fail(3)) SWIG_fail;
31518 }
31519 }
31520 {
31521 PyThreadState* __tstate = wxPyBeginAllowThreads();
31522 (arg1)->SetSizerAndFit(arg2,arg3);
31523
31524 wxPyEndAllowThreads(__tstate);
31525 if (PyErr_Occurred()) SWIG_fail;
31526 }
31527 Py_INCREF(Py_None); resultobj = Py_None;
31528 return resultobj;
31529 fail:
31530 return NULL;
31531 }
31532
31533
31534 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31535 PyObject *resultobj;
31536 wxWindow *arg1 = (wxWindow *) 0 ;
31537 wxSizer *result;
31538 PyObject * obj0 = 0 ;
31539 char *kwnames[] = {
31540 (char *) "self", NULL
31541 };
31542
31543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31545 if (SWIG_arg_fail(1)) SWIG_fail;
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31549
31550 wxPyEndAllowThreads(__tstate);
31551 if (PyErr_Occurred()) SWIG_fail;
31552 }
31553 {
31554 resultobj = wxPyMake_wxSizer(result, 0);
31555 }
31556 return resultobj;
31557 fail:
31558 return NULL;
31559 }
31560
31561
31562 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31563 PyObject *resultobj;
31564 wxWindow *arg1 = (wxWindow *) 0 ;
31565 wxSizer *arg2 = (wxSizer *) 0 ;
31566 PyObject * obj0 = 0 ;
31567 PyObject * obj1 = 0 ;
31568 char *kwnames[] = {
31569 (char *) "self",(char *) "sizer", NULL
31570 };
31571
31572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31574 if (SWIG_arg_fail(1)) SWIG_fail;
31575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31576 if (SWIG_arg_fail(2)) SWIG_fail;
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->SetContainingSizer(arg2);
31580
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 Py_INCREF(Py_None); resultobj = Py_None;
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj;
31593 wxWindow *arg1 = (wxWindow *) 0 ;
31594 wxSizer *result;
31595 PyObject * obj0 = 0 ;
31596 char *kwnames[] = {
31597 (char *) "self", NULL
31598 };
31599
31600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31602 if (SWIG_arg_fail(1)) SWIG_fail;
31603 {
31604 PyThreadState* __tstate = wxPyBeginAllowThreads();
31605 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31606
31607 wxPyEndAllowThreads(__tstate);
31608 if (PyErr_Occurred()) SWIG_fail;
31609 }
31610 {
31611 resultobj = wxPyMake_wxSizer(result, 0);
31612 }
31613 return resultobj;
31614 fail:
31615 return NULL;
31616 }
31617
31618
31619 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31620 PyObject *resultobj;
31621 wxWindow *arg1 = (wxWindow *) 0 ;
31622 PyObject * obj0 = 0 ;
31623 char *kwnames[] = {
31624 (char *) "self", NULL
31625 };
31626
31627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31629 if (SWIG_arg_fail(1)) SWIG_fail;
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 (arg1)->InheritAttributes();
31633
31634 wxPyEndAllowThreads(__tstate);
31635 if (PyErr_Occurred()) SWIG_fail;
31636 }
31637 Py_INCREF(Py_None); resultobj = Py_None;
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31645 PyObject *resultobj;
31646 wxWindow *arg1 = (wxWindow *) 0 ;
31647 bool result;
31648 PyObject * obj0 = 0 ;
31649 char *kwnames[] = {
31650 (char *) "self", NULL
31651 };
31652
31653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31655 if (SWIG_arg_fail(1)) SWIG_fail;
31656 {
31657 PyThreadState* __tstate = wxPyBeginAllowThreads();
31658 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31659
31660 wxPyEndAllowThreads(__tstate);
31661 if (PyErr_Occurred()) SWIG_fail;
31662 }
31663 {
31664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31665 }
31666 return resultobj;
31667 fail:
31668 return NULL;
31669 }
31670
31671
31672 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31673 PyObject *obj;
31674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31675 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31676 Py_INCREF(obj);
31677 return Py_BuildValue((char *)"");
31678 }
31679 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj;
31681 long arg1 ;
31682 wxWindow *arg2 = (wxWindow *) NULL ;
31683 wxWindow *result;
31684 PyObject * obj0 = 0 ;
31685 PyObject * obj1 = 0 ;
31686 char *kwnames[] = {
31687 (char *) "id",(char *) "parent", NULL
31688 };
31689
31690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31691 {
31692 arg1 = (long)(SWIG_As_long(obj0));
31693 if (SWIG_arg_fail(1)) SWIG_fail;
31694 }
31695 if (obj1) {
31696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31697 if (SWIG_arg_fail(2)) SWIG_fail;
31698 }
31699 {
31700 if (!wxPyCheckForApp()) SWIG_fail;
31701 PyThreadState* __tstate = wxPyBeginAllowThreads();
31702 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31703
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 {
31708 resultobj = wxPyMake_wxObject(result, 0);
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj;
31718 wxString *arg1 = 0 ;
31719 wxWindow *arg2 = (wxWindow *) NULL ;
31720 wxWindow *result;
31721 bool temp1 = false ;
31722 PyObject * obj0 = 0 ;
31723 PyObject * obj1 = 0 ;
31724 char *kwnames[] = {
31725 (char *) "name",(char *) "parent", NULL
31726 };
31727
31728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31729 {
31730 arg1 = wxString_in_helper(obj0);
31731 if (arg1 == NULL) SWIG_fail;
31732 temp1 = true;
31733 }
31734 if (obj1) {
31735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31736 if (SWIG_arg_fail(2)) SWIG_fail;
31737 }
31738 {
31739 if (!wxPyCheckForApp()) SWIG_fail;
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31742
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 {
31747 resultobj = wxPyMake_wxObject(result, 0);
31748 }
31749 {
31750 if (temp1)
31751 delete arg1;
31752 }
31753 return resultobj;
31754 fail:
31755 {
31756 if (temp1)
31757 delete arg1;
31758 }
31759 return NULL;
31760 }
31761
31762
31763 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31764 PyObject *resultobj;
31765 wxString *arg1 = 0 ;
31766 wxWindow *arg2 = (wxWindow *) NULL ;
31767 wxWindow *result;
31768 bool temp1 = false ;
31769 PyObject * obj0 = 0 ;
31770 PyObject * obj1 = 0 ;
31771 char *kwnames[] = {
31772 (char *) "label",(char *) "parent", NULL
31773 };
31774
31775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31776 {
31777 arg1 = wxString_in_helper(obj0);
31778 if (arg1 == NULL) SWIG_fail;
31779 temp1 = true;
31780 }
31781 if (obj1) {
31782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31783 if (SWIG_arg_fail(2)) SWIG_fail;
31784 }
31785 {
31786 if (!wxPyCheckForApp()) SWIG_fail;
31787 PyThreadState* __tstate = wxPyBeginAllowThreads();
31788 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31789
31790 wxPyEndAllowThreads(__tstate);
31791 if (PyErr_Occurred()) SWIG_fail;
31792 }
31793 {
31794 resultobj = wxPyMake_wxObject(result, 0);
31795 }
31796 {
31797 if (temp1)
31798 delete arg1;
31799 }
31800 return resultobj;
31801 fail:
31802 {
31803 if (temp1)
31804 delete arg1;
31805 }
31806 return NULL;
31807 }
31808
31809
31810 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31811 PyObject *resultobj;
31812 wxWindow *arg1 = (wxWindow *) 0 ;
31813 unsigned long arg2 ;
31814 wxWindow *result;
31815 PyObject * obj0 = 0 ;
31816 PyObject * obj1 = 0 ;
31817 char *kwnames[] = {
31818 (char *) "parent",(char *) "_hWnd", NULL
31819 };
31820
31821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31823 if (SWIG_arg_fail(1)) SWIG_fail;
31824 {
31825 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31826 if (SWIG_arg_fail(2)) SWIG_fail;
31827 }
31828 {
31829 PyThreadState* __tstate = wxPyBeginAllowThreads();
31830 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31831
31832 wxPyEndAllowThreads(__tstate);
31833 if (PyErr_Occurred()) SWIG_fail;
31834 }
31835 {
31836 resultobj = wxPyMake_wxObject(result, 0);
31837 }
31838 return resultobj;
31839 fail:
31840 return NULL;
31841 }
31842
31843
31844 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31845 PyObject *resultobj;
31846 wxValidator *result;
31847 char *kwnames[] = {
31848 NULL
31849 };
31850
31851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 result = (wxValidator *)new wxValidator();
31855
31856 wxPyEndAllowThreads(__tstate);
31857 if (PyErr_Occurred()) SWIG_fail;
31858 }
31859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31860 return resultobj;
31861 fail:
31862 return NULL;
31863 }
31864
31865
31866 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31867 PyObject *resultobj;
31868 wxValidator *arg1 = (wxValidator *) 0 ;
31869 wxValidator *result;
31870 PyObject * obj0 = 0 ;
31871 char *kwnames[] = {
31872 (char *) "self", NULL
31873 };
31874
31875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31877 if (SWIG_arg_fail(1)) SWIG_fail;
31878 {
31879 PyThreadState* __tstate = wxPyBeginAllowThreads();
31880 result = (wxValidator *)(arg1)->Clone();
31881
31882 wxPyEndAllowThreads(__tstate);
31883 if (PyErr_Occurred()) SWIG_fail;
31884 }
31885 {
31886 resultobj = wxPyMake_wxObject(result, 0);
31887 }
31888 return resultobj;
31889 fail:
31890 return NULL;
31891 }
31892
31893
31894 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31895 PyObject *resultobj;
31896 wxValidator *arg1 = (wxValidator *) 0 ;
31897 wxWindow *arg2 = (wxWindow *) 0 ;
31898 bool result;
31899 PyObject * obj0 = 0 ;
31900 PyObject * obj1 = 0 ;
31901 char *kwnames[] = {
31902 (char *) "self",(char *) "parent", NULL
31903 };
31904
31905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31907 if (SWIG_arg_fail(1)) SWIG_fail;
31908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31909 if (SWIG_arg_fail(2)) SWIG_fail;
31910 {
31911 PyThreadState* __tstate = wxPyBeginAllowThreads();
31912 result = (bool)(arg1)->Validate(arg2);
31913
31914 wxPyEndAllowThreads(__tstate);
31915 if (PyErr_Occurred()) SWIG_fail;
31916 }
31917 {
31918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31919 }
31920 return resultobj;
31921 fail:
31922 return NULL;
31923 }
31924
31925
31926 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31927 PyObject *resultobj;
31928 wxValidator *arg1 = (wxValidator *) 0 ;
31929 bool result;
31930 PyObject * obj0 = 0 ;
31931 char *kwnames[] = {
31932 (char *) "self", NULL
31933 };
31934
31935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31937 if (SWIG_arg_fail(1)) SWIG_fail;
31938 {
31939 PyThreadState* __tstate = wxPyBeginAllowThreads();
31940 result = (bool)(arg1)->TransferToWindow();
31941
31942 wxPyEndAllowThreads(__tstate);
31943 if (PyErr_Occurred()) SWIG_fail;
31944 }
31945 {
31946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31947 }
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31955 PyObject *resultobj;
31956 wxValidator *arg1 = (wxValidator *) 0 ;
31957 bool result;
31958 PyObject * obj0 = 0 ;
31959 char *kwnames[] = {
31960 (char *) "self", NULL
31961 };
31962
31963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31965 if (SWIG_arg_fail(1)) SWIG_fail;
31966 {
31967 PyThreadState* __tstate = wxPyBeginAllowThreads();
31968 result = (bool)(arg1)->TransferFromWindow();
31969
31970 wxPyEndAllowThreads(__tstate);
31971 if (PyErr_Occurred()) SWIG_fail;
31972 }
31973 {
31974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31975 }
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31983 PyObject *resultobj;
31984 wxValidator *arg1 = (wxValidator *) 0 ;
31985 wxWindow *result;
31986 PyObject * obj0 = 0 ;
31987 char *kwnames[] = {
31988 (char *) "self", NULL
31989 };
31990
31991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31993 if (SWIG_arg_fail(1)) SWIG_fail;
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (wxWindow *)(arg1)->GetWindow();
31997
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 {
32002 resultobj = wxPyMake_wxObject(result, 0);
32003 }
32004 return resultobj;
32005 fail:
32006 return NULL;
32007 }
32008
32009
32010 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32011 PyObject *resultobj;
32012 wxValidator *arg1 = (wxValidator *) 0 ;
32013 wxWindow *arg2 = (wxWindow *) 0 ;
32014 PyObject * obj0 = 0 ;
32015 PyObject * obj1 = 0 ;
32016 char *kwnames[] = {
32017 (char *) "self",(char *) "window", NULL
32018 };
32019
32020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32022 if (SWIG_arg_fail(1)) SWIG_fail;
32023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32024 if (SWIG_arg_fail(2)) SWIG_fail;
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 (arg1)->SetWindow(arg2);
32028
32029 wxPyEndAllowThreads(__tstate);
32030 if (PyErr_Occurred()) SWIG_fail;
32031 }
32032 Py_INCREF(Py_None); resultobj = Py_None;
32033 return resultobj;
32034 fail:
32035 return NULL;
32036 }
32037
32038
32039 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32040 PyObject *resultobj;
32041 bool result;
32042 char *kwnames[] = {
32043 NULL
32044 };
32045
32046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32047 {
32048 PyThreadState* __tstate = wxPyBeginAllowThreads();
32049 result = (bool)wxValidator::IsSilent();
32050
32051 wxPyEndAllowThreads(__tstate);
32052 if (PyErr_Occurred()) SWIG_fail;
32053 }
32054 {
32055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32056 }
32057 return resultobj;
32058 fail:
32059 return NULL;
32060 }
32061
32062
32063 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32064 PyObject *resultobj;
32065 int arg1 = (int) true ;
32066 PyObject * obj0 = 0 ;
32067 char *kwnames[] = {
32068 (char *) "doIt", NULL
32069 };
32070
32071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32072 if (obj0) {
32073 {
32074 arg1 = (int)(SWIG_As_int(obj0));
32075 if (SWIG_arg_fail(1)) SWIG_fail;
32076 }
32077 }
32078 {
32079 PyThreadState* __tstate = wxPyBeginAllowThreads();
32080 wxValidator::SetBellOnError(arg1);
32081
32082 wxPyEndAllowThreads(__tstate);
32083 if (PyErr_Occurred()) SWIG_fail;
32084 }
32085 Py_INCREF(Py_None); resultobj = Py_None;
32086 return resultobj;
32087 fail:
32088 return NULL;
32089 }
32090
32091
32092 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32093 PyObject *obj;
32094 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32095 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32096 Py_INCREF(obj);
32097 return Py_BuildValue((char *)"");
32098 }
32099 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32100 PyObject *resultobj;
32101 wxPyValidator *result;
32102 char *kwnames[] = {
32103 NULL
32104 };
32105
32106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32107 {
32108 PyThreadState* __tstate = wxPyBeginAllowThreads();
32109 result = (wxPyValidator *)new wxPyValidator();
32110
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32115 return resultobj;
32116 fail:
32117 return NULL;
32118 }
32119
32120
32121 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32122 PyObject *resultobj;
32123 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32124 PyObject *arg2 = (PyObject *) 0 ;
32125 PyObject *arg3 = (PyObject *) 0 ;
32126 int arg4 = (int) true ;
32127 PyObject * obj0 = 0 ;
32128 PyObject * obj1 = 0 ;
32129 PyObject * obj2 = 0 ;
32130 PyObject * obj3 = 0 ;
32131 char *kwnames[] = {
32132 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32133 };
32134
32135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32137 if (SWIG_arg_fail(1)) SWIG_fail;
32138 arg2 = obj1;
32139 arg3 = obj2;
32140 if (obj3) {
32141 {
32142 arg4 = (int)(SWIG_As_int(obj3));
32143 if (SWIG_arg_fail(4)) SWIG_fail;
32144 }
32145 }
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32149
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 Py_INCREF(Py_None); resultobj = Py_None;
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32161 PyObject *obj;
32162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32163 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32164 Py_INCREF(obj);
32165 return Py_BuildValue((char *)"");
32166 }
32167 static int _wrap_DefaultValidator_set(PyObject *) {
32168 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32169 return 1;
32170 }
32171
32172
32173 static PyObject *_wrap_DefaultValidator_get(void) {
32174 PyObject *pyobj;
32175
32176 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32177 return pyobj;
32178 }
32179
32180
32181 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32182 PyObject *resultobj;
32183 wxString const &arg1_defvalue = wxPyEmptyString ;
32184 wxString *arg1 = (wxString *) &arg1_defvalue ;
32185 long arg2 = (long) 0 ;
32186 wxMenu *result;
32187 bool temp1 = false ;
32188 PyObject * obj0 = 0 ;
32189 PyObject * obj1 = 0 ;
32190 char *kwnames[] = {
32191 (char *) "title",(char *) "style", NULL
32192 };
32193
32194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32195 if (obj0) {
32196 {
32197 arg1 = wxString_in_helper(obj0);
32198 if (arg1 == NULL) SWIG_fail;
32199 temp1 = true;
32200 }
32201 }
32202 if (obj1) {
32203 {
32204 arg2 = (long)(SWIG_As_long(obj1));
32205 if (SWIG_arg_fail(2)) SWIG_fail;
32206 }
32207 }
32208 {
32209 if (!wxPyCheckForApp()) SWIG_fail;
32210 PyThreadState* __tstate = wxPyBeginAllowThreads();
32211 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32212
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32217 {
32218 if (temp1)
32219 delete arg1;
32220 }
32221 return resultobj;
32222 fail:
32223 {
32224 if (temp1)
32225 delete arg1;
32226 }
32227 return NULL;
32228 }
32229
32230
32231 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32232 PyObject *resultobj;
32233 wxMenu *arg1 = (wxMenu *) 0 ;
32234 int arg2 ;
32235 wxString *arg3 = 0 ;
32236 wxString const &arg4_defvalue = wxPyEmptyString ;
32237 wxString *arg4 = (wxString *) &arg4_defvalue ;
32238 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32239 wxMenuItem *result;
32240 bool temp3 = false ;
32241 bool temp4 = false ;
32242 PyObject * obj0 = 0 ;
32243 PyObject * obj1 = 0 ;
32244 PyObject * obj2 = 0 ;
32245 PyObject * obj3 = 0 ;
32246 PyObject * obj4 = 0 ;
32247 char *kwnames[] = {
32248 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32249 };
32250
32251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32253 if (SWIG_arg_fail(1)) SWIG_fail;
32254 {
32255 arg2 = (int)(SWIG_As_int(obj1));
32256 if (SWIG_arg_fail(2)) SWIG_fail;
32257 }
32258 {
32259 arg3 = wxString_in_helper(obj2);
32260 if (arg3 == NULL) SWIG_fail;
32261 temp3 = true;
32262 }
32263 if (obj3) {
32264 {
32265 arg4 = wxString_in_helper(obj3);
32266 if (arg4 == NULL) SWIG_fail;
32267 temp4 = true;
32268 }
32269 }
32270 if (obj4) {
32271 {
32272 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32273 if (SWIG_arg_fail(5)) SWIG_fail;
32274 }
32275 }
32276 {
32277 PyThreadState* __tstate = wxPyBeginAllowThreads();
32278 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32279
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = wxPyMake_wxObject(result, 0);
32285 }
32286 {
32287 if (temp3)
32288 delete arg3;
32289 }
32290 {
32291 if (temp4)
32292 delete arg4;
32293 }
32294 return resultobj;
32295 fail:
32296 {
32297 if (temp3)
32298 delete arg3;
32299 }
32300 {
32301 if (temp4)
32302 delete arg4;
32303 }
32304 return NULL;
32305 }
32306
32307
32308 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32309 PyObject *resultobj;
32310 wxMenu *arg1 = (wxMenu *) 0 ;
32311 wxMenuItem *result;
32312 PyObject * obj0 = 0 ;
32313 char *kwnames[] = {
32314 (char *) "self", NULL
32315 };
32316
32317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32319 if (SWIG_arg_fail(1)) SWIG_fail;
32320 {
32321 PyThreadState* __tstate = wxPyBeginAllowThreads();
32322 result = (wxMenuItem *)(arg1)->AppendSeparator();
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_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32337 PyObject *resultobj;
32338 wxMenu *arg1 = (wxMenu *) 0 ;
32339 int arg2 ;
32340 wxString *arg3 = 0 ;
32341 wxString const &arg4_defvalue = wxPyEmptyString ;
32342 wxString *arg4 = (wxString *) &arg4_defvalue ;
32343 wxMenuItem *result;
32344 bool temp3 = false ;
32345 bool temp4 = false ;
32346 PyObject * obj0 = 0 ;
32347 PyObject * obj1 = 0 ;
32348 PyObject * obj2 = 0 ;
32349 PyObject * obj3 = 0 ;
32350 char *kwnames[] = {
32351 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32352 };
32353
32354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32356 if (SWIG_arg_fail(1)) SWIG_fail;
32357 {
32358 arg2 = (int)(SWIG_As_int(obj1));
32359 if (SWIG_arg_fail(2)) SWIG_fail;
32360 }
32361 {
32362 arg3 = wxString_in_helper(obj2);
32363 if (arg3 == NULL) SWIG_fail;
32364 temp3 = true;
32365 }
32366 if (obj3) {
32367 {
32368 arg4 = wxString_in_helper(obj3);
32369 if (arg4 == NULL) SWIG_fail;
32370 temp4 = true;
32371 }
32372 }
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32376
32377 wxPyEndAllowThreads(__tstate);
32378 if (PyErr_Occurred()) SWIG_fail;
32379 }
32380 {
32381 resultobj = wxPyMake_wxObject(result, 0);
32382 }
32383 {
32384 if (temp3)
32385 delete arg3;
32386 }
32387 {
32388 if (temp4)
32389 delete arg4;
32390 }
32391 return resultobj;
32392 fail:
32393 {
32394 if (temp3)
32395 delete arg3;
32396 }
32397 {
32398 if (temp4)
32399 delete arg4;
32400 }
32401 return NULL;
32402 }
32403
32404
32405 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32406 PyObject *resultobj;
32407 wxMenu *arg1 = (wxMenu *) 0 ;
32408 int arg2 ;
32409 wxString *arg3 = 0 ;
32410 wxString const &arg4_defvalue = wxPyEmptyString ;
32411 wxString *arg4 = (wxString *) &arg4_defvalue ;
32412 wxMenuItem *result;
32413 bool temp3 = false ;
32414 bool temp4 = false ;
32415 PyObject * obj0 = 0 ;
32416 PyObject * obj1 = 0 ;
32417 PyObject * obj2 = 0 ;
32418 PyObject * obj3 = 0 ;
32419 char *kwnames[] = {
32420 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32421 };
32422
32423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32425 if (SWIG_arg_fail(1)) SWIG_fail;
32426 {
32427 arg2 = (int)(SWIG_As_int(obj1));
32428 if (SWIG_arg_fail(2)) SWIG_fail;
32429 }
32430 {
32431 arg3 = wxString_in_helper(obj2);
32432 if (arg3 == NULL) SWIG_fail;
32433 temp3 = true;
32434 }
32435 if (obj3) {
32436 {
32437 arg4 = wxString_in_helper(obj3);
32438 if (arg4 == NULL) SWIG_fail;
32439 temp4 = true;
32440 }
32441 }
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32445
32446 wxPyEndAllowThreads(__tstate);
32447 if (PyErr_Occurred()) SWIG_fail;
32448 }
32449 {
32450 resultobj = wxPyMake_wxObject(result, 0);
32451 }
32452 {
32453 if (temp3)
32454 delete arg3;
32455 }
32456 {
32457 if (temp4)
32458 delete arg4;
32459 }
32460 return resultobj;
32461 fail:
32462 {
32463 if (temp3)
32464 delete arg3;
32465 }
32466 {
32467 if (temp4)
32468 delete arg4;
32469 }
32470 return NULL;
32471 }
32472
32473
32474 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32475 PyObject *resultobj;
32476 wxMenu *arg1 = (wxMenu *) 0 ;
32477 int arg2 ;
32478 wxString *arg3 = 0 ;
32479 wxMenu *arg4 = (wxMenu *) 0 ;
32480 wxString const &arg5_defvalue = wxPyEmptyString ;
32481 wxString *arg5 = (wxString *) &arg5_defvalue ;
32482 wxMenuItem *result;
32483 bool temp3 = false ;
32484 bool temp5 = false ;
32485 PyObject * obj0 = 0 ;
32486 PyObject * obj1 = 0 ;
32487 PyObject * obj2 = 0 ;
32488 PyObject * obj3 = 0 ;
32489 PyObject * obj4 = 0 ;
32490 char *kwnames[] = {
32491 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32492 };
32493
32494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32496 if (SWIG_arg_fail(1)) SWIG_fail;
32497 {
32498 arg2 = (int)(SWIG_As_int(obj1));
32499 if (SWIG_arg_fail(2)) SWIG_fail;
32500 }
32501 {
32502 arg3 = wxString_in_helper(obj2);
32503 if (arg3 == NULL) SWIG_fail;
32504 temp3 = true;
32505 }
32506 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32507 if (SWIG_arg_fail(4)) SWIG_fail;
32508 if (obj4) {
32509 {
32510 arg5 = wxString_in_helper(obj4);
32511 if (arg5 == NULL) SWIG_fail;
32512 temp5 = true;
32513 }
32514 }
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32518
32519 wxPyEndAllowThreads(__tstate);
32520 if (PyErr_Occurred()) SWIG_fail;
32521 }
32522 {
32523 resultobj = wxPyMake_wxObject(result, 0);
32524 }
32525 {
32526 if (temp3)
32527 delete arg3;
32528 }
32529 {
32530 if (temp5)
32531 delete arg5;
32532 }
32533 return resultobj;
32534 fail:
32535 {
32536 if (temp3)
32537 delete arg3;
32538 }
32539 {
32540 if (temp5)
32541 delete arg5;
32542 }
32543 return NULL;
32544 }
32545
32546
32547 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32548 PyObject *resultobj;
32549 wxMenu *arg1 = (wxMenu *) 0 ;
32550 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32551 wxMenuItem *result;
32552 PyObject * obj0 = 0 ;
32553 PyObject * obj1 = 0 ;
32554 char *kwnames[] = {
32555 (char *) "self",(char *) "item", NULL
32556 };
32557
32558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32560 if (SWIG_arg_fail(1)) SWIG_fail;
32561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32562 if (SWIG_arg_fail(2)) SWIG_fail;
32563 {
32564 PyThreadState* __tstate = wxPyBeginAllowThreads();
32565 result = (wxMenuItem *)(arg1)->Append(arg2);
32566
32567 wxPyEndAllowThreads(__tstate);
32568 if (PyErr_Occurred()) SWIG_fail;
32569 }
32570 {
32571 resultobj = wxPyMake_wxObject(result, 0);
32572 }
32573 return resultobj;
32574 fail:
32575 return NULL;
32576 }
32577
32578
32579 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32580 PyObject *resultobj;
32581 wxMenu *arg1 = (wxMenu *) 0 ;
32582 PyObject * obj0 = 0 ;
32583 char *kwnames[] = {
32584 (char *) "self", NULL
32585 };
32586
32587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32589 if (SWIG_arg_fail(1)) SWIG_fail;
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 (arg1)->Break();
32593
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 Py_INCREF(Py_None); resultobj = Py_None;
32598 return resultobj;
32599 fail:
32600 return NULL;
32601 }
32602
32603
32604 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32605 PyObject *resultobj;
32606 wxMenu *arg1 = (wxMenu *) 0 ;
32607 size_t arg2 ;
32608 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32609 wxMenuItem *result;
32610 PyObject * obj0 = 0 ;
32611 PyObject * obj1 = 0 ;
32612 PyObject * obj2 = 0 ;
32613 char *kwnames[] = {
32614 (char *) "self",(char *) "pos",(char *) "item", NULL
32615 };
32616
32617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32619 if (SWIG_arg_fail(1)) SWIG_fail;
32620 {
32621 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32622 if (SWIG_arg_fail(2)) SWIG_fail;
32623 }
32624 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32625 if (SWIG_arg_fail(3)) SWIG_fail;
32626 {
32627 PyThreadState* __tstate = wxPyBeginAllowThreads();
32628 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32629
32630 wxPyEndAllowThreads(__tstate);
32631 if (PyErr_Occurred()) SWIG_fail;
32632 }
32633 {
32634 resultobj = wxPyMake_wxObject(result, 0);
32635 }
32636 return resultobj;
32637 fail:
32638 return NULL;
32639 }
32640
32641
32642 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32643 PyObject *resultobj;
32644 wxMenu *arg1 = (wxMenu *) 0 ;
32645 size_t arg2 ;
32646 int arg3 ;
32647 wxString *arg4 = 0 ;
32648 wxString const &arg5_defvalue = wxPyEmptyString ;
32649 wxString *arg5 = (wxString *) &arg5_defvalue ;
32650 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32651 wxMenuItem *result;
32652 bool temp4 = false ;
32653 bool temp5 = false ;
32654 PyObject * obj0 = 0 ;
32655 PyObject * obj1 = 0 ;
32656 PyObject * obj2 = 0 ;
32657 PyObject * obj3 = 0 ;
32658 PyObject * obj4 = 0 ;
32659 PyObject * obj5 = 0 ;
32660 char *kwnames[] = {
32661 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32662 };
32663
32664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32666 if (SWIG_arg_fail(1)) SWIG_fail;
32667 {
32668 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32669 if (SWIG_arg_fail(2)) SWIG_fail;
32670 }
32671 {
32672 arg3 = (int)(SWIG_As_int(obj2));
32673 if (SWIG_arg_fail(3)) SWIG_fail;
32674 }
32675 {
32676 arg4 = wxString_in_helper(obj3);
32677 if (arg4 == NULL) SWIG_fail;
32678 temp4 = true;
32679 }
32680 if (obj4) {
32681 {
32682 arg5 = wxString_in_helper(obj4);
32683 if (arg5 == NULL) SWIG_fail;
32684 temp5 = true;
32685 }
32686 }
32687 if (obj5) {
32688 {
32689 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32690 if (SWIG_arg_fail(6)) SWIG_fail;
32691 }
32692 }
32693 {
32694 PyThreadState* __tstate = wxPyBeginAllowThreads();
32695 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32696
32697 wxPyEndAllowThreads(__tstate);
32698 if (PyErr_Occurred()) SWIG_fail;
32699 }
32700 {
32701 resultobj = wxPyMake_wxObject(result, 0);
32702 }
32703 {
32704 if (temp4)
32705 delete arg4;
32706 }
32707 {
32708 if (temp5)
32709 delete arg5;
32710 }
32711 return resultobj;
32712 fail:
32713 {
32714 if (temp4)
32715 delete arg4;
32716 }
32717 {
32718 if (temp5)
32719 delete arg5;
32720 }
32721 return NULL;
32722 }
32723
32724
32725 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32726 PyObject *resultobj;
32727 wxMenu *arg1 = (wxMenu *) 0 ;
32728 size_t arg2 ;
32729 wxMenuItem *result;
32730 PyObject * obj0 = 0 ;
32731 PyObject * obj1 = 0 ;
32732 char *kwnames[] = {
32733 (char *) "self",(char *) "pos", NULL
32734 };
32735
32736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32738 if (SWIG_arg_fail(1)) SWIG_fail;
32739 {
32740 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32741 if (SWIG_arg_fail(2)) SWIG_fail;
32742 }
32743 {
32744 PyThreadState* __tstate = wxPyBeginAllowThreads();
32745 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32746
32747 wxPyEndAllowThreads(__tstate);
32748 if (PyErr_Occurred()) SWIG_fail;
32749 }
32750 {
32751 resultobj = wxPyMake_wxObject(result, 0);
32752 }
32753 return resultobj;
32754 fail:
32755 return NULL;
32756 }
32757
32758
32759 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32760 PyObject *resultobj;
32761 wxMenu *arg1 = (wxMenu *) 0 ;
32762 size_t arg2 ;
32763 int arg3 ;
32764 wxString *arg4 = 0 ;
32765 wxString const &arg5_defvalue = wxPyEmptyString ;
32766 wxString *arg5 = (wxString *) &arg5_defvalue ;
32767 wxMenuItem *result;
32768 bool temp4 = false ;
32769 bool temp5 = false ;
32770 PyObject * obj0 = 0 ;
32771 PyObject * obj1 = 0 ;
32772 PyObject * obj2 = 0 ;
32773 PyObject * obj3 = 0 ;
32774 PyObject * obj4 = 0 ;
32775 char *kwnames[] = {
32776 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32777 };
32778
32779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32781 if (SWIG_arg_fail(1)) SWIG_fail;
32782 {
32783 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32784 if (SWIG_arg_fail(2)) SWIG_fail;
32785 }
32786 {
32787 arg3 = (int)(SWIG_As_int(obj2));
32788 if (SWIG_arg_fail(3)) SWIG_fail;
32789 }
32790 {
32791 arg4 = wxString_in_helper(obj3);
32792 if (arg4 == NULL) SWIG_fail;
32793 temp4 = true;
32794 }
32795 if (obj4) {
32796 {
32797 arg5 = wxString_in_helper(obj4);
32798 if (arg5 == NULL) SWIG_fail;
32799 temp5 = true;
32800 }
32801 }
32802 {
32803 PyThreadState* __tstate = wxPyBeginAllowThreads();
32804 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32805
32806 wxPyEndAllowThreads(__tstate);
32807 if (PyErr_Occurred()) SWIG_fail;
32808 }
32809 {
32810 resultobj = wxPyMake_wxObject(result, 0);
32811 }
32812 {
32813 if (temp4)
32814 delete arg4;
32815 }
32816 {
32817 if (temp5)
32818 delete arg5;
32819 }
32820 return resultobj;
32821 fail:
32822 {
32823 if (temp4)
32824 delete arg4;
32825 }
32826 {
32827 if (temp5)
32828 delete arg5;
32829 }
32830 return NULL;
32831 }
32832
32833
32834 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32835 PyObject *resultobj;
32836 wxMenu *arg1 = (wxMenu *) 0 ;
32837 size_t arg2 ;
32838 int arg3 ;
32839 wxString *arg4 = 0 ;
32840 wxString const &arg5_defvalue = wxPyEmptyString ;
32841 wxString *arg5 = (wxString *) &arg5_defvalue ;
32842 wxMenuItem *result;
32843 bool temp4 = false ;
32844 bool temp5 = false ;
32845 PyObject * obj0 = 0 ;
32846 PyObject * obj1 = 0 ;
32847 PyObject * obj2 = 0 ;
32848 PyObject * obj3 = 0 ;
32849 PyObject * obj4 = 0 ;
32850 char *kwnames[] = {
32851 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32852 };
32853
32854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32856 if (SWIG_arg_fail(1)) SWIG_fail;
32857 {
32858 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32859 if (SWIG_arg_fail(2)) SWIG_fail;
32860 }
32861 {
32862 arg3 = (int)(SWIG_As_int(obj2));
32863 if (SWIG_arg_fail(3)) SWIG_fail;
32864 }
32865 {
32866 arg4 = wxString_in_helper(obj3);
32867 if (arg4 == NULL) SWIG_fail;
32868 temp4 = true;
32869 }
32870 if (obj4) {
32871 {
32872 arg5 = wxString_in_helper(obj4);
32873 if (arg5 == NULL) SWIG_fail;
32874 temp5 = true;
32875 }
32876 }
32877 {
32878 PyThreadState* __tstate = wxPyBeginAllowThreads();
32879 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32880
32881 wxPyEndAllowThreads(__tstate);
32882 if (PyErr_Occurred()) SWIG_fail;
32883 }
32884 {
32885 resultobj = wxPyMake_wxObject(result, 0);
32886 }
32887 {
32888 if (temp4)
32889 delete arg4;
32890 }
32891 {
32892 if (temp5)
32893 delete arg5;
32894 }
32895 return resultobj;
32896 fail:
32897 {
32898 if (temp4)
32899 delete arg4;
32900 }
32901 {
32902 if (temp5)
32903 delete arg5;
32904 }
32905 return NULL;
32906 }
32907
32908
32909 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32910 PyObject *resultobj;
32911 wxMenu *arg1 = (wxMenu *) 0 ;
32912 size_t arg2 ;
32913 int arg3 ;
32914 wxString *arg4 = 0 ;
32915 wxMenu *arg5 = (wxMenu *) 0 ;
32916 wxString const &arg6_defvalue = wxPyEmptyString ;
32917 wxString *arg6 = (wxString *) &arg6_defvalue ;
32918 wxMenuItem *result;
32919 bool temp4 = false ;
32920 bool temp6 = false ;
32921 PyObject * obj0 = 0 ;
32922 PyObject * obj1 = 0 ;
32923 PyObject * obj2 = 0 ;
32924 PyObject * obj3 = 0 ;
32925 PyObject * obj4 = 0 ;
32926 PyObject * obj5 = 0 ;
32927 char *kwnames[] = {
32928 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32929 };
32930
32931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32933 if (SWIG_arg_fail(1)) SWIG_fail;
32934 {
32935 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32936 if (SWIG_arg_fail(2)) SWIG_fail;
32937 }
32938 {
32939 arg3 = (int)(SWIG_As_int(obj2));
32940 if (SWIG_arg_fail(3)) SWIG_fail;
32941 }
32942 {
32943 arg4 = wxString_in_helper(obj3);
32944 if (arg4 == NULL) SWIG_fail;
32945 temp4 = true;
32946 }
32947 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32948 if (SWIG_arg_fail(5)) SWIG_fail;
32949 if (obj5) {
32950 {
32951 arg6 = wxString_in_helper(obj5);
32952 if (arg6 == NULL) SWIG_fail;
32953 temp6 = true;
32954 }
32955 }
32956 {
32957 PyThreadState* __tstate = wxPyBeginAllowThreads();
32958 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32959
32960 wxPyEndAllowThreads(__tstate);
32961 if (PyErr_Occurred()) SWIG_fail;
32962 }
32963 {
32964 resultobj = wxPyMake_wxObject(result, 0);
32965 }
32966 {
32967 if (temp4)
32968 delete arg4;
32969 }
32970 {
32971 if (temp6)
32972 delete arg6;
32973 }
32974 return resultobj;
32975 fail:
32976 {
32977 if (temp4)
32978 delete arg4;
32979 }
32980 {
32981 if (temp6)
32982 delete arg6;
32983 }
32984 return NULL;
32985 }
32986
32987
32988 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32989 PyObject *resultobj;
32990 wxMenu *arg1 = (wxMenu *) 0 ;
32991 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32992 wxMenuItem *result;
32993 PyObject * obj0 = 0 ;
32994 PyObject * obj1 = 0 ;
32995 char *kwnames[] = {
32996 (char *) "self",(char *) "item", NULL
32997 };
32998
32999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33001 if (SWIG_arg_fail(1)) SWIG_fail;
33002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33003 if (SWIG_arg_fail(2)) SWIG_fail;
33004 {
33005 PyThreadState* __tstate = wxPyBeginAllowThreads();
33006 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33007
33008 wxPyEndAllowThreads(__tstate);
33009 if (PyErr_Occurred()) SWIG_fail;
33010 }
33011 {
33012 resultobj = wxPyMake_wxObject(result, 0);
33013 }
33014 return resultobj;
33015 fail:
33016 return NULL;
33017 }
33018
33019
33020 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33021 PyObject *resultobj;
33022 wxMenu *arg1 = (wxMenu *) 0 ;
33023 int arg2 ;
33024 wxString *arg3 = 0 ;
33025 wxString const &arg4_defvalue = wxPyEmptyString ;
33026 wxString *arg4 = (wxString *) &arg4_defvalue ;
33027 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33028 wxMenuItem *result;
33029 bool temp3 = false ;
33030 bool temp4 = false ;
33031 PyObject * obj0 = 0 ;
33032 PyObject * obj1 = 0 ;
33033 PyObject * obj2 = 0 ;
33034 PyObject * obj3 = 0 ;
33035 PyObject * obj4 = 0 ;
33036 char *kwnames[] = {
33037 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33038 };
33039
33040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33042 if (SWIG_arg_fail(1)) SWIG_fail;
33043 {
33044 arg2 = (int)(SWIG_As_int(obj1));
33045 if (SWIG_arg_fail(2)) SWIG_fail;
33046 }
33047 {
33048 arg3 = wxString_in_helper(obj2);
33049 if (arg3 == NULL) SWIG_fail;
33050 temp3 = true;
33051 }
33052 if (obj3) {
33053 {
33054 arg4 = wxString_in_helper(obj3);
33055 if (arg4 == NULL) SWIG_fail;
33056 temp4 = true;
33057 }
33058 }
33059 if (obj4) {
33060 {
33061 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33062 if (SWIG_arg_fail(5)) SWIG_fail;
33063 }
33064 }
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33068
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 {
33073 resultobj = wxPyMake_wxObject(result, 0);
33074 }
33075 {
33076 if (temp3)
33077 delete arg3;
33078 }
33079 {
33080 if (temp4)
33081 delete arg4;
33082 }
33083 return resultobj;
33084 fail:
33085 {
33086 if (temp3)
33087 delete arg3;
33088 }
33089 {
33090 if (temp4)
33091 delete arg4;
33092 }
33093 return NULL;
33094 }
33095
33096
33097 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33098 PyObject *resultobj;
33099 wxMenu *arg1 = (wxMenu *) 0 ;
33100 wxMenuItem *result;
33101 PyObject * obj0 = 0 ;
33102 char *kwnames[] = {
33103 (char *) "self", NULL
33104 };
33105
33106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33108 if (SWIG_arg_fail(1)) SWIG_fail;
33109 {
33110 PyThreadState* __tstate = wxPyBeginAllowThreads();
33111 result = (wxMenuItem *)(arg1)->PrependSeparator();
33112
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 {
33117 resultobj = wxPyMake_wxObject(result, 0);
33118 }
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33126 PyObject *resultobj;
33127 wxMenu *arg1 = (wxMenu *) 0 ;
33128 int arg2 ;
33129 wxString *arg3 = 0 ;
33130 wxString const &arg4_defvalue = wxPyEmptyString ;
33131 wxString *arg4 = (wxString *) &arg4_defvalue ;
33132 wxMenuItem *result;
33133 bool temp3 = false ;
33134 bool temp4 = false ;
33135 PyObject * obj0 = 0 ;
33136 PyObject * obj1 = 0 ;
33137 PyObject * obj2 = 0 ;
33138 PyObject * obj3 = 0 ;
33139 char *kwnames[] = {
33140 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33141 };
33142
33143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33145 if (SWIG_arg_fail(1)) SWIG_fail;
33146 {
33147 arg2 = (int)(SWIG_As_int(obj1));
33148 if (SWIG_arg_fail(2)) SWIG_fail;
33149 }
33150 {
33151 arg3 = wxString_in_helper(obj2);
33152 if (arg3 == NULL) SWIG_fail;
33153 temp3 = true;
33154 }
33155 if (obj3) {
33156 {
33157 arg4 = wxString_in_helper(obj3);
33158 if (arg4 == NULL) SWIG_fail;
33159 temp4 = true;
33160 }
33161 }
33162 {
33163 PyThreadState* __tstate = wxPyBeginAllowThreads();
33164 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33165
33166 wxPyEndAllowThreads(__tstate);
33167 if (PyErr_Occurred()) SWIG_fail;
33168 }
33169 {
33170 resultobj = wxPyMake_wxObject(result, 0);
33171 }
33172 {
33173 if (temp3)
33174 delete arg3;
33175 }
33176 {
33177 if (temp4)
33178 delete arg4;
33179 }
33180 return resultobj;
33181 fail:
33182 {
33183 if (temp3)
33184 delete arg3;
33185 }
33186 {
33187 if (temp4)
33188 delete arg4;
33189 }
33190 return NULL;
33191 }
33192
33193
33194 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33195 PyObject *resultobj;
33196 wxMenu *arg1 = (wxMenu *) 0 ;
33197 int arg2 ;
33198 wxString *arg3 = 0 ;
33199 wxString const &arg4_defvalue = wxPyEmptyString ;
33200 wxString *arg4 = (wxString *) &arg4_defvalue ;
33201 wxMenuItem *result;
33202 bool temp3 = false ;
33203 bool temp4 = false ;
33204 PyObject * obj0 = 0 ;
33205 PyObject * obj1 = 0 ;
33206 PyObject * obj2 = 0 ;
33207 PyObject * obj3 = 0 ;
33208 char *kwnames[] = {
33209 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33210 };
33211
33212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33214 if (SWIG_arg_fail(1)) SWIG_fail;
33215 {
33216 arg2 = (int)(SWIG_As_int(obj1));
33217 if (SWIG_arg_fail(2)) SWIG_fail;
33218 }
33219 {
33220 arg3 = wxString_in_helper(obj2);
33221 if (arg3 == NULL) SWIG_fail;
33222 temp3 = true;
33223 }
33224 if (obj3) {
33225 {
33226 arg4 = wxString_in_helper(obj3);
33227 if (arg4 == NULL) SWIG_fail;
33228 temp4 = true;
33229 }
33230 }
33231 {
33232 PyThreadState* __tstate = wxPyBeginAllowThreads();
33233 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33234
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 {
33239 resultobj = wxPyMake_wxObject(result, 0);
33240 }
33241 {
33242 if (temp3)
33243 delete arg3;
33244 }
33245 {
33246 if (temp4)
33247 delete arg4;
33248 }
33249 return resultobj;
33250 fail:
33251 {
33252 if (temp3)
33253 delete arg3;
33254 }
33255 {
33256 if (temp4)
33257 delete arg4;
33258 }
33259 return NULL;
33260 }
33261
33262
33263 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33264 PyObject *resultobj;
33265 wxMenu *arg1 = (wxMenu *) 0 ;
33266 int arg2 ;
33267 wxString *arg3 = 0 ;
33268 wxMenu *arg4 = (wxMenu *) 0 ;
33269 wxString const &arg5_defvalue = wxPyEmptyString ;
33270 wxString *arg5 = (wxString *) &arg5_defvalue ;
33271 wxMenuItem *result;
33272 bool temp3 = false ;
33273 bool temp5 = false ;
33274 PyObject * obj0 = 0 ;
33275 PyObject * obj1 = 0 ;
33276 PyObject * obj2 = 0 ;
33277 PyObject * obj3 = 0 ;
33278 PyObject * obj4 = 0 ;
33279 char *kwnames[] = {
33280 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33281 };
33282
33283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33285 if (SWIG_arg_fail(1)) SWIG_fail;
33286 {
33287 arg2 = (int)(SWIG_As_int(obj1));
33288 if (SWIG_arg_fail(2)) SWIG_fail;
33289 }
33290 {
33291 arg3 = wxString_in_helper(obj2);
33292 if (arg3 == NULL) SWIG_fail;
33293 temp3 = true;
33294 }
33295 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33296 if (SWIG_arg_fail(4)) SWIG_fail;
33297 if (obj4) {
33298 {
33299 arg5 = wxString_in_helper(obj4);
33300 if (arg5 == NULL) SWIG_fail;
33301 temp5 = true;
33302 }
33303 }
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33307
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 {
33312 resultobj = wxPyMake_wxObject(result, 0);
33313 }
33314 {
33315 if (temp3)
33316 delete arg3;
33317 }
33318 {
33319 if (temp5)
33320 delete arg5;
33321 }
33322 return resultobj;
33323 fail:
33324 {
33325 if (temp3)
33326 delete arg3;
33327 }
33328 {
33329 if (temp5)
33330 delete arg5;
33331 }
33332 return NULL;
33333 }
33334
33335
33336 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33337 PyObject *resultobj;
33338 wxMenu *arg1 = (wxMenu *) 0 ;
33339 int arg2 ;
33340 wxMenuItem *result;
33341 PyObject * obj0 = 0 ;
33342 PyObject * obj1 = 0 ;
33343 char *kwnames[] = {
33344 (char *) "self",(char *) "id", NULL
33345 };
33346
33347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33349 if (SWIG_arg_fail(1)) SWIG_fail;
33350 {
33351 arg2 = (int)(SWIG_As_int(obj1));
33352 if (SWIG_arg_fail(2)) SWIG_fail;
33353 }
33354 {
33355 PyThreadState* __tstate = wxPyBeginAllowThreads();
33356 result = (wxMenuItem *)(arg1)->Remove(arg2);
33357
33358 wxPyEndAllowThreads(__tstate);
33359 if (PyErr_Occurred()) SWIG_fail;
33360 }
33361 {
33362 resultobj = wxPyMake_wxObject(result, 0);
33363 }
33364 return resultobj;
33365 fail:
33366 return NULL;
33367 }
33368
33369
33370 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33371 PyObject *resultobj;
33372 wxMenu *arg1 = (wxMenu *) 0 ;
33373 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33374 wxMenuItem *result;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 char *kwnames[] = {
33378 (char *) "self",(char *) "item", NULL
33379 };
33380
33381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33383 if (SWIG_arg_fail(1)) SWIG_fail;
33384 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33385 if (SWIG_arg_fail(2)) SWIG_fail;
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (wxMenuItem *)(arg1)->Remove(arg2);
33389
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 {
33394 resultobj = wxPyMake_wxObject(result, 0);
33395 }
33396 return resultobj;
33397 fail:
33398 return NULL;
33399 }
33400
33401
33402 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33403 PyObject *resultobj;
33404 wxMenu *arg1 = (wxMenu *) 0 ;
33405 int arg2 ;
33406 bool result;
33407 PyObject * obj0 = 0 ;
33408 PyObject * obj1 = 0 ;
33409 char *kwnames[] = {
33410 (char *) "self",(char *) "id", NULL
33411 };
33412
33413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33415 if (SWIG_arg_fail(1)) SWIG_fail;
33416 {
33417 arg2 = (int)(SWIG_As_int(obj1));
33418 if (SWIG_arg_fail(2)) SWIG_fail;
33419 }
33420 {
33421 PyThreadState* __tstate = wxPyBeginAllowThreads();
33422 result = (bool)(arg1)->Delete(arg2);
33423
33424 wxPyEndAllowThreads(__tstate);
33425 if (PyErr_Occurred()) SWIG_fail;
33426 }
33427 {
33428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33429 }
33430 return resultobj;
33431 fail:
33432 return NULL;
33433 }
33434
33435
33436 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33437 PyObject *resultobj;
33438 wxMenu *arg1 = (wxMenu *) 0 ;
33439 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33440 bool result;
33441 PyObject * obj0 = 0 ;
33442 PyObject * obj1 = 0 ;
33443 char *kwnames[] = {
33444 (char *) "self",(char *) "item", NULL
33445 };
33446
33447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33449 if (SWIG_arg_fail(1)) SWIG_fail;
33450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33451 if (SWIG_arg_fail(2)) SWIG_fail;
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 result = (bool)(arg1)->Delete(arg2);
33455
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 {
33460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33461 }
33462 return resultobj;
33463 fail:
33464 return NULL;
33465 }
33466
33467
33468 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33469 PyObject *resultobj;
33470 wxMenu *arg1 = (wxMenu *) 0 ;
33471 PyObject * obj0 = 0 ;
33472 char *kwnames[] = {
33473 (char *) "self", NULL
33474 };
33475
33476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33478 if (SWIG_arg_fail(1)) SWIG_fail;
33479 {
33480 PyThreadState* __tstate = wxPyBeginAllowThreads();
33481 wxMenu_Destroy(arg1);
33482
33483 wxPyEndAllowThreads(__tstate);
33484 if (PyErr_Occurred()) SWIG_fail;
33485 }
33486 Py_INCREF(Py_None); resultobj = Py_None;
33487 return resultobj;
33488 fail:
33489 return NULL;
33490 }
33491
33492
33493 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33494 PyObject *resultobj;
33495 wxMenu *arg1 = (wxMenu *) 0 ;
33496 int arg2 ;
33497 bool result;
33498 PyObject * obj0 = 0 ;
33499 PyObject * obj1 = 0 ;
33500 char *kwnames[] = {
33501 (char *) "self",(char *) "id", NULL
33502 };
33503
33504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33506 if (SWIG_arg_fail(1)) SWIG_fail;
33507 {
33508 arg2 = (int)(SWIG_As_int(obj1));
33509 if (SWIG_arg_fail(2)) SWIG_fail;
33510 }
33511 {
33512 PyThreadState* __tstate = wxPyBeginAllowThreads();
33513 result = (bool)(arg1)->Destroy(arg2);
33514
33515 wxPyEndAllowThreads(__tstate);
33516 if (PyErr_Occurred()) SWIG_fail;
33517 }
33518 {
33519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33520 }
33521 return resultobj;
33522 fail:
33523 return NULL;
33524 }
33525
33526
33527 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33528 PyObject *resultobj;
33529 wxMenu *arg1 = (wxMenu *) 0 ;
33530 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33531 bool result;
33532 PyObject * obj0 = 0 ;
33533 PyObject * obj1 = 0 ;
33534 char *kwnames[] = {
33535 (char *) "self",(char *) "item", NULL
33536 };
33537
33538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33540 if (SWIG_arg_fail(1)) SWIG_fail;
33541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33542 if (SWIG_arg_fail(2)) SWIG_fail;
33543 {
33544 PyThreadState* __tstate = wxPyBeginAllowThreads();
33545 result = (bool)(arg1)->Destroy(arg2);
33546
33547 wxPyEndAllowThreads(__tstate);
33548 if (PyErr_Occurred()) SWIG_fail;
33549 }
33550 {
33551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33552 }
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33560 PyObject *resultobj;
33561 wxMenu *arg1 = (wxMenu *) 0 ;
33562 size_t result;
33563 PyObject * obj0 = 0 ;
33564 char *kwnames[] = {
33565 (char *) "self", NULL
33566 };
33567
33568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33570 if (SWIG_arg_fail(1)) SWIG_fail;
33571 {
33572 PyThreadState* __tstate = wxPyBeginAllowThreads();
33573 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33574
33575 wxPyEndAllowThreads(__tstate);
33576 if (PyErr_Occurred()) SWIG_fail;
33577 }
33578 {
33579 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33580 }
33581 return resultobj;
33582 fail:
33583 return NULL;
33584 }
33585
33586
33587 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33588 PyObject *resultobj;
33589 wxMenu *arg1 = (wxMenu *) 0 ;
33590 PyObject *result;
33591 PyObject * obj0 = 0 ;
33592 char *kwnames[] = {
33593 (char *) "self", NULL
33594 };
33595
33596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33598 if (SWIG_arg_fail(1)) SWIG_fail;
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33602
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 resultobj = result;
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33614 PyObject *resultobj;
33615 wxMenu *arg1 = (wxMenu *) 0 ;
33616 wxString *arg2 = 0 ;
33617 int result;
33618 bool temp2 = false ;
33619 PyObject * obj0 = 0 ;
33620 PyObject * obj1 = 0 ;
33621 char *kwnames[] = {
33622 (char *) "self",(char *) "item", NULL
33623 };
33624
33625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33627 if (SWIG_arg_fail(1)) SWIG_fail;
33628 {
33629 arg2 = wxString_in_helper(obj1);
33630 if (arg2 == NULL) SWIG_fail;
33631 temp2 = true;
33632 }
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33636
33637 wxPyEndAllowThreads(__tstate);
33638 if (PyErr_Occurred()) SWIG_fail;
33639 }
33640 {
33641 resultobj = SWIG_From_int((int)(result));
33642 }
33643 {
33644 if (temp2)
33645 delete arg2;
33646 }
33647 return resultobj;
33648 fail:
33649 {
33650 if (temp2)
33651 delete arg2;
33652 }
33653 return NULL;
33654 }
33655
33656
33657 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33658 PyObject *resultobj;
33659 wxMenu *arg1 = (wxMenu *) 0 ;
33660 int arg2 ;
33661 wxMenuItem *result;
33662 PyObject * obj0 = 0 ;
33663 PyObject * obj1 = 0 ;
33664 char *kwnames[] = {
33665 (char *) "self",(char *) "id", NULL
33666 };
33667
33668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33670 if (SWIG_arg_fail(1)) SWIG_fail;
33671 {
33672 arg2 = (int)(SWIG_As_int(obj1));
33673 if (SWIG_arg_fail(2)) SWIG_fail;
33674 }
33675 {
33676 PyThreadState* __tstate = wxPyBeginAllowThreads();
33677 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33678
33679 wxPyEndAllowThreads(__tstate);
33680 if (PyErr_Occurred()) SWIG_fail;
33681 }
33682 {
33683 resultobj = wxPyMake_wxObject(result, 0);
33684 }
33685 return resultobj;
33686 fail:
33687 return NULL;
33688 }
33689
33690
33691 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33692 PyObject *resultobj;
33693 wxMenu *arg1 = (wxMenu *) 0 ;
33694 size_t arg2 ;
33695 wxMenuItem *result;
33696 PyObject * obj0 = 0 ;
33697 PyObject * obj1 = 0 ;
33698 char *kwnames[] = {
33699 (char *) "self",(char *) "position", NULL
33700 };
33701
33702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33704 if (SWIG_arg_fail(1)) SWIG_fail;
33705 {
33706 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33707 if (SWIG_arg_fail(2)) SWIG_fail;
33708 }
33709 {
33710 PyThreadState* __tstate = wxPyBeginAllowThreads();
33711 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33712
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 {
33717 resultobj = wxPyMake_wxObject(result, 0);
33718 }
33719 return resultobj;
33720 fail:
33721 return NULL;
33722 }
33723
33724
33725 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33726 PyObject *resultobj;
33727 wxMenu *arg1 = (wxMenu *) 0 ;
33728 int arg2 ;
33729 bool arg3 ;
33730 PyObject * obj0 = 0 ;
33731 PyObject * obj1 = 0 ;
33732 PyObject * obj2 = 0 ;
33733 char *kwnames[] = {
33734 (char *) "self",(char *) "id",(char *) "enable", NULL
33735 };
33736
33737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33739 if (SWIG_arg_fail(1)) SWIG_fail;
33740 {
33741 arg2 = (int)(SWIG_As_int(obj1));
33742 if (SWIG_arg_fail(2)) SWIG_fail;
33743 }
33744 {
33745 arg3 = (bool)(SWIG_As_bool(obj2));
33746 if (SWIG_arg_fail(3)) SWIG_fail;
33747 }
33748 {
33749 PyThreadState* __tstate = wxPyBeginAllowThreads();
33750 (arg1)->Enable(arg2,arg3);
33751
33752 wxPyEndAllowThreads(__tstate);
33753 if (PyErr_Occurred()) SWIG_fail;
33754 }
33755 Py_INCREF(Py_None); resultobj = Py_None;
33756 return resultobj;
33757 fail:
33758 return NULL;
33759 }
33760
33761
33762 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33763 PyObject *resultobj;
33764 wxMenu *arg1 = (wxMenu *) 0 ;
33765 int arg2 ;
33766 bool result;
33767 PyObject * obj0 = 0 ;
33768 PyObject * obj1 = 0 ;
33769 char *kwnames[] = {
33770 (char *) "self",(char *) "id", NULL
33771 };
33772
33773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33775 if (SWIG_arg_fail(1)) SWIG_fail;
33776 {
33777 arg2 = (int)(SWIG_As_int(obj1));
33778 if (SWIG_arg_fail(2)) SWIG_fail;
33779 }
33780 {
33781 PyThreadState* __tstate = wxPyBeginAllowThreads();
33782 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33783
33784 wxPyEndAllowThreads(__tstate);
33785 if (PyErr_Occurred()) SWIG_fail;
33786 }
33787 {
33788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33789 }
33790 return resultobj;
33791 fail:
33792 return NULL;
33793 }
33794
33795
33796 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33797 PyObject *resultobj;
33798 wxMenu *arg1 = (wxMenu *) 0 ;
33799 int arg2 ;
33800 bool arg3 ;
33801 PyObject * obj0 = 0 ;
33802 PyObject * obj1 = 0 ;
33803 PyObject * obj2 = 0 ;
33804 char *kwnames[] = {
33805 (char *) "self",(char *) "id",(char *) "check", NULL
33806 };
33807
33808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33810 if (SWIG_arg_fail(1)) SWIG_fail;
33811 {
33812 arg2 = (int)(SWIG_As_int(obj1));
33813 if (SWIG_arg_fail(2)) SWIG_fail;
33814 }
33815 {
33816 arg3 = (bool)(SWIG_As_bool(obj2));
33817 if (SWIG_arg_fail(3)) SWIG_fail;
33818 }
33819 {
33820 PyThreadState* __tstate = wxPyBeginAllowThreads();
33821 (arg1)->Check(arg2,arg3);
33822
33823 wxPyEndAllowThreads(__tstate);
33824 if (PyErr_Occurred()) SWIG_fail;
33825 }
33826 Py_INCREF(Py_None); resultobj = Py_None;
33827 return resultobj;
33828 fail:
33829 return NULL;
33830 }
33831
33832
33833 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33834 PyObject *resultobj;
33835 wxMenu *arg1 = (wxMenu *) 0 ;
33836 int arg2 ;
33837 bool result;
33838 PyObject * obj0 = 0 ;
33839 PyObject * obj1 = 0 ;
33840 char *kwnames[] = {
33841 (char *) "self",(char *) "id", NULL
33842 };
33843
33844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33846 if (SWIG_arg_fail(1)) SWIG_fail;
33847 {
33848 arg2 = (int)(SWIG_As_int(obj1));
33849 if (SWIG_arg_fail(2)) SWIG_fail;
33850 }
33851 {
33852 PyThreadState* __tstate = wxPyBeginAllowThreads();
33853 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33854
33855 wxPyEndAllowThreads(__tstate);
33856 if (PyErr_Occurred()) SWIG_fail;
33857 }
33858 {
33859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33860 }
33861 return resultobj;
33862 fail:
33863 return NULL;
33864 }
33865
33866
33867 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33868 PyObject *resultobj;
33869 wxMenu *arg1 = (wxMenu *) 0 ;
33870 int arg2 ;
33871 wxString *arg3 = 0 ;
33872 bool temp3 = false ;
33873 PyObject * obj0 = 0 ;
33874 PyObject * obj1 = 0 ;
33875 PyObject * obj2 = 0 ;
33876 char *kwnames[] = {
33877 (char *) "self",(char *) "id",(char *) "label", NULL
33878 };
33879
33880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33882 if (SWIG_arg_fail(1)) SWIG_fail;
33883 {
33884 arg2 = (int)(SWIG_As_int(obj1));
33885 if (SWIG_arg_fail(2)) SWIG_fail;
33886 }
33887 {
33888 arg3 = wxString_in_helper(obj2);
33889 if (arg3 == NULL) SWIG_fail;
33890 temp3 = true;
33891 }
33892 {
33893 PyThreadState* __tstate = wxPyBeginAllowThreads();
33894 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33895
33896 wxPyEndAllowThreads(__tstate);
33897 if (PyErr_Occurred()) SWIG_fail;
33898 }
33899 Py_INCREF(Py_None); resultobj = Py_None;
33900 {
33901 if (temp3)
33902 delete arg3;
33903 }
33904 return resultobj;
33905 fail:
33906 {
33907 if (temp3)
33908 delete arg3;
33909 }
33910 return NULL;
33911 }
33912
33913
33914 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj;
33916 wxMenu *arg1 = (wxMenu *) 0 ;
33917 int arg2 ;
33918 wxString result;
33919 PyObject * obj0 = 0 ;
33920 PyObject * obj1 = 0 ;
33921 char *kwnames[] = {
33922 (char *) "self",(char *) "id", NULL
33923 };
33924
33925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33927 if (SWIG_arg_fail(1)) SWIG_fail;
33928 {
33929 arg2 = (int)(SWIG_As_int(obj1));
33930 if (SWIG_arg_fail(2)) SWIG_fail;
33931 }
33932 {
33933 PyThreadState* __tstate = wxPyBeginAllowThreads();
33934 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33935
33936 wxPyEndAllowThreads(__tstate);
33937 if (PyErr_Occurred()) SWIG_fail;
33938 }
33939 {
33940 #if wxUSE_UNICODE
33941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33942 #else
33943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33944 #endif
33945 }
33946 return resultobj;
33947 fail:
33948 return NULL;
33949 }
33950
33951
33952 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33953 PyObject *resultobj;
33954 wxMenu *arg1 = (wxMenu *) 0 ;
33955 int arg2 ;
33956 wxString *arg3 = 0 ;
33957 bool temp3 = false ;
33958 PyObject * obj0 = 0 ;
33959 PyObject * obj1 = 0 ;
33960 PyObject * obj2 = 0 ;
33961 char *kwnames[] = {
33962 (char *) "self",(char *) "id",(char *) "helpString", NULL
33963 };
33964
33965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33967 if (SWIG_arg_fail(1)) SWIG_fail;
33968 {
33969 arg2 = (int)(SWIG_As_int(obj1));
33970 if (SWIG_arg_fail(2)) SWIG_fail;
33971 }
33972 {
33973 arg3 = wxString_in_helper(obj2);
33974 if (arg3 == NULL) SWIG_fail;
33975 temp3 = true;
33976 }
33977 {
33978 PyThreadState* __tstate = wxPyBeginAllowThreads();
33979 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33980
33981 wxPyEndAllowThreads(__tstate);
33982 if (PyErr_Occurred()) SWIG_fail;
33983 }
33984 Py_INCREF(Py_None); resultobj = Py_None;
33985 {
33986 if (temp3)
33987 delete arg3;
33988 }
33989 return resultobj;
33990 fail:
33991 {
33992 if (temp3)
33993 delete arg3;
33994 }
33995 return NULL;
33996 }
33997
33998
33999 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34000 PyObject *resultobj;
34001 wxMenu *arg1 = (wxMenu *) 0 ;
34002 int arg2 ;
34003 wxString result;
34004 PyObject * obj0 = 0 ;
34005 PyObject * obj1 = 0 ;
34006 char *kwnames[] = {
34007 (char *) "self",(char *) "id", NULL
34008 };
34009
34010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34012 if (SWIG_arg_fail(1)) SWIG_fail;
34013 {
34014 arg2 = (int)(SWIG_As_int(obj1));
34015 if (SWIG_arg_fail(2)) SWIG_fail;
34016 }
34017 {
34018 PyThreadState* __tstate = wxPyBeginAllowThreads();
34019 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34020
34021 wxPyEndAllowThreads(__tstate);
34022 if (PyErr_Occurred()) SWIG_fail;
34023 }
34024 {
34025 #if wxUSE_UNICODE
34026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34027 #else
34028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34029 #endif
34030 }
34031 return resultobj;
34032 fail:
34033 return NULL;
34034 }
34035
34036
34037 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34038 PyObject *resultobj;
34039 wxMenu *arg1 = (wxMenu *) 0 ;
34040 wxString *arg2 = 0 ;
34041 bool temp2 = false ;
34042 PyObject * obj0 = 0 ;
34043 PyObject * obj1 = 0 ;
34044 char *kwnames[] = {
34045 (char *) "self",(char *) "title", NULL
34046 };
34047
34048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34050 if (SWIG_arg_fail(1)) SWIG_fail;
34051 {
34052 arg2 = wxString_in_helper(obj1);
34053 if (arg2 == NULL) SWIG_fail;
34054 temp2 = true;
34055 }
34056 {
34057 PyThreadState* __tstate = wxPyBeginAllowThreads();
34058 (arg1)->SetTitle((wxString const &)*arg2);
34059
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 Py_INCREF(Py_None); resultobj = Py_None;
34064 {
34065 if (temp2)
34066 delete arg2;
34067 }
34068 return resultobj;
34069 fail:
34070 {
34071 if (temp2)
34072 delete arg2;
34073 }
34074 return NULL;
34075 }
34076
34077
34078 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34079 PyObject *resultobj;
34080 wxMenu *arg1 = (wxMenu *) 0 ;
34081 wxString result;
34082 PyObject * obj0 = 0 ;
34083 char *kwnames[] = {
34084 (char *) "self", NULL
34085 };
34086
34087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34089 if (SWIG_arg_fail(1)) SWIG_fail;
34090 {
34091 PyThreadState* __tstate = wxPyBeginAllowThreads();
34092 result = ((wxMenu const *)arg1)->GetTitle();
34093
34094 wxPyEndAllowThreads(__tstate);
34095 if (PyErr_Occurred()) SWIG_fail;
34096 }
34097 {
34098 #if wxUSE_UNICODE
34099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34100 #else
34101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34102 #endif
34103 }
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34111 PyObject *resultobj;
34112 wxMenu *arg1 = (wxMenu *) 0 ;
34113 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34114 PyObject * obj0 = 0 ;
34115 PyObject * obj1 = 0 ;
34116 char *kwnames[] = {
34117 (char *) "self",(char *) "handler", NULL
34118 };
34119
34120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34122 if (SWIG_arg_fail(1)) SWIG_fail;
34123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34124 if (SWIG_arg_fail(2)) SWIG_fail;
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 (arg1)->SetEventHandler(arg2);
34128
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 Py_INCREF(Py_None); resultobj = Py_None;
34133 return resultobj;
34134 fail:
34135 return NULL;
34136 }
34137
34138
34139 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34140 PyObject *resultobj;
34141 wxMenu *arg1 = (wxMenu *) 0 ;
34142 wxEvtHandler *result;
34143 PyObject * obj0 = 0 ;
34144 char *kwnames[] = {
34145 (char *) "self", NULL
34146 };
34147
34148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34150 if (SWIG_arg_fail(1)) SWIG_fail;
34151 {
34152 PyThreadState* __tstate = wxPyBeginAllowThreads();
34153 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34154
34155 wxPyEndAllowThreads(__tstate);
34156 if (PyErr_Occurred()) SWIG_fail;
34157 }
34158 {
34159 resultobj = wxPyMake_wxObject(result, 0);
34160 }
34161 return resultobj;
34162 fail:
34163 return NULL;
34164 }
34165
34166
34167 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34168 PyObject *resultobj;
34169 wxMenu *arg1 = (wxMenu *) 0 ;
34170 wxWindow *arg2 = (wxWindow *) 0 ;
34171 PyObject * obj0 = 0 ;
34172 PyObject * obj1 = 0 ;
34173 char *kwnames[] = {
34174 (char *) "self",(char *) "win", NULL
34175 };
34176
34177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34179 if (SWIG_arg_fail(1)) SWIG_fail;
34180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34181 if (SWIG_arg_fail(2)) SWIG_fail;
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 (arg1)->SetInvokingWindow(arg2);
34185
34186 wxPyEndAllowThreads(__tstate);
34187 if (PyErr_Occurred()) SWIG_fail;
34188 }
34189 Py_INCREF(Py_None); resultobj = Py_None;
34190 return resultobj;
34191 fail:
34192 return NULL;
34193 }
34194
34195
34196 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34197 PyObject *resultobj;
34198 wxMenu *arg1 = (wxMenu *) 0 ;
34199 wxWindow *result;
34200 PyObject * obj0 = 0 ;
34201 char *kwnames[] = {
34202 (char *) "self", NULL
34203 };
34204
34205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34207 if (SWIG_arg_fail(1)) SWIG_fail;
34208 {
34209 PyThreadState* __tstate = wxPyBeginAllowThreads();
34210 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34211
34212 wxPyEndAllowThreads(__tstate);
34213 if (PyErr_Occurred()) SWIG_fail;
34214 }
34215 {
34216 resultobj = wxPyMake_wxObject(result, 0);
34217 }
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34225 PyObject *resultobj;
34226 wxMenu *arg1 = (wxMenu *) 0 ;
34227 long result;
34228 PyObject * obj0 = 0 ;
34229 char *kwnames[] = {
34230 (char *) "self", NULL
34231 };
34232
34233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34235 if (SWIG_arg_fail(1)) SWIG_fail;
34236 {
34237 PyThreadState* __tstate = wxPyBeginAllowThreads();
34238 result = (long)((wxMenu const *)arg1)->GetStyle();
34239
34240 wxPyEndAllowThreads(__tstate);
34241 if (PyErr_Occurred()) SWIG_fail;
34242 }
34243 {
34244 resultobj = SWIG_From_long((long)(result));
34245 }
34246 return resultobj;
34247 fail:
34248 return NULL;
34249 }
34250
34251
34252 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34253 PyObject *resultobj;
34254 wxMenu *arg1 = (wxMenu *) 0 ;
34255 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34256 PyObject * obj0 = 0 ;
34257 PyObject * obj1 = 0 ;
34258 char *kwnames[] = {
34259 (char *) "self",(char *) "source", NULL
34260 };
34261
34262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34264 if (SWIG_arg_fail(1)) SWIG_fail;
34265 if (obj1) {
34266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34267 if (SWIG_arg_fail(2)) SWIG_fail;
34268 }
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 (arg1)->UpdateUI(arg2);
34272
34273 wxPyEndAllowThreads(__tstate);
34274 if (PyErr_Occurred()) SWIG_fail;
34275 }
34276 Py_INCREF(Py_None); resultobj = Py_None;
34277 return resultobj;
34278 fail:
34279 return NULL;
34280 }
34281
34282
34283 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34284 PyObject *resultobj;
34285 wxMenu *arg1 = (wxMenu *) 0 ;
34286 wxMenuBar *result;
34287 PyObject * obj0 = 0 ;
34288 char *kwnames[] = {
34289 (char *) "self", NULL
34290 };
34291
34292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34294 if (SWIG_arg_fail(1)) SWIG_fail;
34295 {
34296 PyThreadState* __tstate = wxPyBeginAllowThreads();
34297 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34298
34299 wxPyEndAllowThreads(__tstate);
34300 if (PyErr_Occurred()) SWIG_fail;
34301 }
34302 {
34303 resultobj = wxPyMake_wxObject(result, 0);
34304 }
34305 return resultobj;
34306 fail:
34307 return NULL;
34308 }
34309
34310
34311 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34312 PyObject *resultobj;
34313 wxMenu *arg1 = (wxMenu *) 0 ;
34314 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34315 PyObject * obj0 = 0 ;
34316 PyObject * obj1 = 0 ;
34317 char *kwnames[] = {
34318 (char *) "self",(char *) "menubar", NULL
34319 };
34320
34321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34323 if (SWIG_arg_fail(1)) SWIG_fail;
34324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34325 if (SWIG_arg_fail(2)) SWIG_fail;
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 (arg1)->Attach(arg2);
34329
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 Py_INCREF(Py_None); resultobj = Py_None;
34334 return resultobj;
34335 fail:
34336 return NULL;
34337 }
34338
34339
34340 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34341 PyObject *resultobj;
34342 wxMenu *arg1 = (wxMenu *) 0 ;
34343 PyObject * obj0 = 0 ;
34344 char *kwnames[] = {
34345 (char *) "self", NULL
34346 };
34347
34348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34350 if (SWIG_arg_fail(1)) SWIG_fail;
34351 {
34352 PyThreadState* __tstate = wxPyBeginAllowThreads();
34353 (arg1)->Detach();
34354
34355 wxPyEndAllowThreads(__tstate);
34356 if (PyErr_Occurred()) SWIG_fail;
34357 }
34358 Py_INCREF(Py_None); resultobj = Py_None;
34359 return resultobj;
34360 fail:
34361 return NULL;
34362 }
34363
34364
34365 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34366 PyObject *resultobj;
34367 wxMenu *arg1 = (wxMenu *) 0 ;
34368 bool result;
34369 PyObject * obj0 = 0 ;
34370 char *kwnames[] = {
34371 (char *) "self", NULL
34372 };
34373
34374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34376 if (SWIG_arg_fail(1)) SWIG_fail;
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 result = (bool)((wxMenu const *)arg1)->IsAttached();
34380
34381 wxPyEndAllowThreads(__tstate);
34382 if (PyErr_Occurred()) SWIG_fail;
34383 }
34384 {
34385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34386 }
34387 return resultobj;
34388 fail:
34389 return NULL;
34390 }
34391
34392
34393 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34394 PyObject *resultobj;
34395 wxMenu *arg1 = (wxMenu *) 0 ;
34396 wxMenu *arg2 = (wxMenu *) 0 ;
34397 PyObject * obj0 = 0 ;
34398 PyObject * obj1 = 0 ;
34399 char *kwnames[] = {
34400 (char *) "self",(char *) "parent", NULL
34401 };
34402
34403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34405 if (SWIG_arg_fail(1)) SWIG_fail;
34406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34407 if (SWIG_arg_fail(2)) SWIG_fail;
34408 {
34409 PyThreadState* __tstate = wxPyBeginAllowThreads();
34410 (arg1)->SetParent(arg2);
34411
34412 wxPyEndAllowThreads(__tstate);
34413 if (PyErr_Occurred()) SWIG_fail;
34414 }
34415 Py_INCREF(Py_None); resultobj = Py_None;
34416 return resultobj;
34417 fail:
34418 return NULL;
34419 }
34420
34421
34422 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34423 PyObject *resultobj;
34424 wxMenu *arg1 = (wxMenu *) 0 ;
34425 wxMenu *result;
34426 PyObject * obj0 = 0 ;
34427 char *kwnames[] = {
34428 (char *) "self", NULL
34429 };
34430
34431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34433 if (SWIG_arg_fail(1)) SWIG_fail;
34434 {
34435 PyThreadState* __tstate = wxPyBeginAllowThreads();
34436 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34437
34438 wxPyEndAllowThreads(__tstate);
34439 if (PyErr_Occurred()) SWIG_fail;
34440 }
34441 {
34442 resultobj = wxPyMake_wxObject(result, 0);
34443 }
34444 return resultobj;
34445 fail:
34446 return NULL;
34447 }
34448
34449
34450 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34451 PyObject *obj;
34452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34453 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34454 Py_INCREF(obj);
34455 return Py_BuildValue((char *)"");
34456 }
34457 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34458 PyObject *resultobj;
34459 long arg1 = (long) 0 ;
34460 wxMenuBar *result;
34461 PyObject * obj0 = 0 ;
34462 char *kwnames[] = {
34463 (char *) "style", NULL
34464 };
34465
34466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34467 if (obj0) {
34468 {
34469 arg1 = (long)(SWIG_As_long(obj0));
34470 if (SWIG_arg_fail(1)) SWIG_fail;
34471 }
34472 }
34473 {
34474 if (!wxPyCheckForApp()) SWIG_fail;
34475 PyThreadState* __tstate = wxPyBeginAllowThreads();
34476 result = (wxMenuBar *)new wxMenuBar(arg1);
34477
34478 wxPyEndAllowThreads(__tstate);
34479 if (PyErr_Occurred()) SWIG_fail;
34480 }
34481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34482 return resultobj;
34483 fail:
34484 return NULL;
34485 }
34486
34487
34488 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34489 PyObject *resultobj;
34490 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34491 wxMenu *arg2 = (wxMenu *) 0 ;
34492 wxString *arg3 = 0 ;
34493 bool result;
34494 bool temp3 = false ;
34495 PyObject * obj0 = 0 ;
34496 PyObject * obj1 = 0 ;
34497 PyObject * obj2 = 0 ;
34498 char *kwnames[] = {
34499 (char *) "self",(char *) "menu",(char *) "title", NULL
34500 };
34501
34502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34504 if (SWIG_arg_fail(1)) SWIG_fail;
34505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34506 if (SWIG_arg_fail(2)) SWIG_fail;
34507 {
34508 arg3 = wxString_in_helper(obj2);
34509 if (arg3 == NULL) SWIG_fail;
34510 temp3 = true;
34511 }
34512 {
34513 PyThreadState* __tstate = wxPyBeginAllowThreads();
34514 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34515
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 {
34520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34521 }
34522 {
34523 if (temp3)
34524 delete arg3;
34525 }
34526 return resultobj;
34527 fail:
34528 {
34529 if (temp3)
34530 delete arg3;
34531 }
34532 return NULL;
34533 }
34534
34535
34536 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34537 PyObject *resultobj;
34538 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34539 size_t arg2 ;
34540 wxMenu *arg3 = (wxMenu *) 0 ;
34541 wxString *arg4 = 0 ;
34542 bool result;
34543 bool temp4 = false ;
34544 PyObject * obj0 = 0 ;
34545 PyObject * obj1 = 0 ;
34546 PyObject * obj2 = 0 ;
34547 PyObject * obj3 = 0 ;
34548 char *kwnames[] = {
34549 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34550 };
34551
34552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34554 if (SWIG_arg_fail(1)) SWIG_fail;
34555 {
34556 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34557 if (SWIG_arg_fail(2)) SWIG_fail;
34558 }
34559 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34560 if (SWIG_arg_fail(3)) SWIG_fail;
34561 {
34562 arg4 = wxString_in_helper(obj3);
34563 if (arg4 == NULL) SWIG_fail;
34564 temp4 = true;
34565 }
34566 {
34567 PyThreadState* __tstate = wxPyBeginAllowThreads();
34568 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34569
34570 wxPyEndAllowThreads(__tstate);
34571 if (PyErr_Occurred()) SWIG_fail;
34572 }
34573 {
34574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34575 }
34576 {
34577 if (temp4)
34578 delete arg4;
34579 }
34580 return resultobj;
34581 fail:
34582 {
34583 if (temp4)
34584 delete arg4;
34585 }
34586 return NULL;
34587 }
34588
34589
34590 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34591 PyObject *resultobj;
34592 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34593 size_t result;
34594 PyObject * obj0 = 0 ;
34595 char *kwnames[] = {
34596 (char *) "self", NULL
34597 };
34598
34599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34601 if (SWIG_arg_fail(1)) SWIG_fail;
34602 {
34603 PyThreadState* __tstate = wxPyBeginAllowThreads();
34604 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34605
34606 wxPyEndAllowThreads(__tstate);
34607 if (PyErr_Occurred()) SWIG_fail;
34608 }
34609 {
34610 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34611 }
34612 return resultobj;
34613 fail:
34614 return NULL;
34615 }
34616
34617
34618 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34619 PyObject *resultobj;
34620 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34621 size_t arg2 ;
34622 wxMenu *result;
34623 PyObject * obj0 = 0 ;
34624 PyObject * obj1 = 0 ;
34625 char *kwnames[] = {
34626 (char *) "self",(char *) "pos", NULL
34627 };
34628
34629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34631 if (SWIG_arg_fail(1)) SWIG_fail;
34632 {
34633 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34634 if (SWIG_arg_fail(2)) SWIG_fail;
34635 }
34636 {
34637 PyThreadState* __tstate = wxPyBeginAllowThreads();
34638 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34639
34640 wxPyEndAllowThreads(__tstate);
34641 if (PyErr_Occurred()) SWIG_fail;
34642 }
34643 {
34644 resultobj = wxPyMake_wxObject(result, 0);
34645 }
34646 return resultobj;
34647 fail:
34648 return NULL;
34649 }
34650
34651
34652 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34653 PyObject *resultobj;
34654 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34655 size_t arg2 ;
34656 wxMenu *arg3 = (wxMenu *) 0 ;
34657 wxString *arg4 = 0 ;
34658 wxMenu *result;
34659 bool temp4 = false ;
34660 PyObject * obj0 = 0 ;
34661 PyObject * obj1 = 0 ;
34662 PyObject * obj2 = 0 ;
34663 PyObject * obj3 = 0 ;
34664 char *kwnames[] = {
34665 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34666 };
34667
34668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34670 if (SWIG_arg_fail(1)) SWIG_fail;
34671 {
34672 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34673 if (SWIG_arg_fail(2)) SWIG_fail;
34674 }
34675 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34676 if (SWIG_arg_fail(3)) SWIG_fail;
34677 {
34678 arg4 = wxString_in_helper(obj3);
34679 if (arg4 == NULL) SWIG_fail;
34680 temp4 = true;
34681 }
34682 {
34683 PyThreadState* __tstate = wxPyBeginAllowThreads();
34684 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34685
34686 wxPyEndAllowThreads(__tstate);
34687 if (PyErr_Occurred()) SWIG_fail;
34688 }
34689 {
34690 resultobj = wxPyMake_wxObject(result, 0);
34691 }
34692 {
34693 if (temp4)
34694 delete arg4;
34695 }
34696 return resultobj;
34697 fail:
34698 {
34699 if (temp4)
34700 delete arg4;
34701 }
34702 return NULL;
34703 }
34704
34705
34706 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34707 PyObject *resultobj;
34708 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34709 size_t arg2 ;
34710 wxMenu *result;
34711 PyObject * obj0 = 0 ;
34712 PyObject * obj1 = 0 ;
34713 char *kwnames[] = {
34714 (char *) "self",(char *) "pos", NULL
34715 };
34716
34717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34719 if (SWIG_arg_fail(1)) SWIG_fail;
34720 {
34721 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34722 if (SWIG_arg_fail(2)) SWIG_fail;
34723 }
34724 {
34725 PyThreadState* __tstate = wxPyBeginAllowThreads();
34726 result = (wxMenu *)(arg1)->Remove(arg2);
34727
34728 wxPyEndAllowThreads(__tstate);
34729 if (PyErr_Occurred()) SWIG_fail;
34730 }
34731 {
34732 resultobj = wxPyMake_wxObject(result, 0);
34733 }
34734 return resultobj;
34735 fail:
34736 return NULL;
34737 }
34738
34739
34740 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34741 PyObject *resultobj;
34742 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34743 size_t arg2 ;
34744 bool arg3 ;
34745 PyObject * obj0 = 0 ;
34746 PyObject * obj1 = 0 ;
34747 PyObject * obj2 = 0 ;
34748 char *kwnames[] = {
34749 (char *) "self",(char *) "pos",(char *) "enable", NULL
34750 };
34751
34752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34754 if (SWIG_arg_fail(1)) SWIG_fail;
34755 {
34756 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34757 if (SWIG_arg_fail(2)) SWIG_fail;
34758 }
34759 {
34760 arg3 = (bool)(SWIG_As_bool(obj2));
34761 if (SWIG_arg_fail(3)) SWIG_fail;
34762 }
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 (arg1)->EnableTop(arg2,arg3);
34766
34767 wxPyEndAllowThreads(__tstate);
34768 if (PyErr_Occurred()) SWIG_fail;
34769 }
34770 Py_INCREF(Py_None); resultobj = Py_None;
34771 return resultobj;
34772 fail:
34773 return NULL;
34774 }
34775
34776
34777 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34778 PyObject *resultobj;
34779 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34780 size_t arg2 ;
34781 bool result;
34782 PyObject * obj0 = 0 ;
34783 PyObject * obj1 = 0 ;
34784 char *kwnames[] = {
34785 (char *) "self",(char *) "pos", NULL
34786 };
34787
34788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34790 if (SWIG_arg_fail(1)) SWIG_fail;
34791 {
34792 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34793 if (SWIG_arg_fail(2)) SWIG_fail;
34794 }
34795 {
34796 PyThreadState* __tstate = wxPyBeginAllowThreads();
34797 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34798
34799 wxPyEndAllowThreads(__tstate);
34800 if (PyErr_Occurred()) SWIG_fail;
34801 }
34802 {
34803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34804 }
34805 return resultobj;
34806 fail:
34807 return NULL;
34808 }
34809
34810
34811 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34812 PyObject *resultobj;
34813 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34814 size_t arg2 ;
34815 wxString *arg3 = 0 ;
34816 bool temp3 = false ;
34817 PyObject * obj0 = 0 ;
34818 PyObject * obj1 = 0 ;
34819 PyObject * obj2 = 0 ;
34820 char *kwnames[] = {
34821 (char *) "self",(char *) "pos",(char *) "label", NULL
34822 };
34823
34824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34826 if (SWIG_arg_fail(1)) SWIG_fail;
34827 {
34828 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34829 if (SWIG_arg_fail(2)) SWIG_fail;
34830 }
34831 {
34832 arg3 = wxString_in_helper(obj2);
34833 if (arg3 == NULL) SWIG_fail;
34834 temp3 = true;
34835 }
34836 {
34837 PyThreadState* __tstate = wxPyBeginAllowThreads();
34838 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34839
34840 wxPyEndAllowThreads(__tstate);
34841 if (PyErr_Occurred()) SWIG_fail;
34842 }
34843 Py_INCREF(Py_None); resultobj = Py_None;
34844 {
34845 if (temp3)
34846 delete arg3;
34847 }
34848 return resultobj;
34849 fail:
34850 {
34851 if (temp3)
34852 delete arg3;
34853 }
34854 return NULL;
34855 }
34856
34857
34858 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34859 PyObject *resultobj;
34860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34861 size_t arg2 ;
34862 wxString result;
34863 PyObject * obj0 = 0 ;
34864 PyObject * obj1 = 0 ;
34865 char *kwnames[] = {
34866 (char *) "self",(char *) "pos", NULL
34867 };
34868
34869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34871 if (SWIG_arg_fail(1)) SWIG_fail;
34872 {
34873 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34874 if (SWIG_arg_fail(2)) SWIG_fail;
34875 }
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34879
34880 wxPyEndAllowThreads(__tstate);
34881 if (PyErr_Occurred()) SWIG_fail;
34882 }
34883 {
34884 #if wxUSE_UNICODE
34885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34886 #else
34887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34888 #endif
34889 }
34890 return resultobj;
34891 fail:
34892 return NULL;
34893 }
34894
34895
34896 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34897 PyObject *resultobj;
34898 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34899 wxString *arg2 = 0 ;
34900 wxString *arg3 = 0 ;
34901 int result;
34902 bool temp2 = false ;
34903 bool temp3 = false ;
34904 PyObject * obj0 = 0 ;
34905 PyObject * obj1 = 0 ;
34906 PyObject * obj2 = 0 ;
34907 char *kwnames[] = {
34908 (char *) "self",(char *) "menu",(char *) "item", NULL
34909 };
34910
34911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34913 if (SWIG_arg_fail(1)) SWIG_fail;
34914 {
34915 arg2 = wxString_in_helper(obj1);
34916 if (arg2 == NULL) SWIG_fail;
34917 temp2 = true;
34918 }
34919 {
34920 arg3 = wxString_in_helper(obj2);
34921 if (arg3 == NULL) SWIG_fail;
34922 temp3 = true;
34923 }
34924 {
34925 PyThreadState* __tstate = wxPyBeginAllowThreads();
34926 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34927
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 {
34932 resultobj = SWIG_From_int((int)(result));
34933 }
34934 {
34935 if (temp2)
34936 delete arg2;
34937 }
34938 {
34939 if (temp3)
34940 delete arg3;
34941 }
34942 return resultobj;
34943 fail:
34944 {
34945 if (temp2)
34946 delete arg2;
34947 }
34948 {
34949 if (temp3)
34950 delete arg3;
34951 }
34952 return NULL;
34953 }
34954
34955
34956 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34957 PyObject *resultobj;
34958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34959 int arg2 ;
34960 wxMenuItem *result;
34961 PyObject * obj0 = 0 ;
34962 PyObject * obj1 = 0 ;
34963 char *kwnames[] = {
34964 (char *) "self",(char *) "id", NULL
34965 };
34966
34967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34969 if (SWIG_arg_fail(1)) SWIG_fail;
34970 {
34971 arg2 = (int)(SWIG_As_int(obj1));
34972 if (SWIG_arg_fail(2)) SWIG_fail;
34973 }
34974 {
34975 PyThreadState* __tstate = wxPyBeginAllowThreads();
34976 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34977
34978 wxPyEndAllowThreads(__tstate);
34979 if (PyErr_Occurred()) SWIG_fail;
34980 }
34981 {
34982 resultobj = wxPyMake_wxObject(result, 0);
34983 }
34984 return resultobj;
34985 fail:
34986 return NULL;
34987 }
34988
34989
34990 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34991 PyObject *resultobj;
34992 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34993 wxString *arg2 = 0 ;
34994 int result;
34995 bool temp2 = false ;
34996 PyObject * obj0 = 0 ;
34997 PyObject * obj1 = 0 ;
34998 char *kwnames[] = {
34999 (char *) "self",(char *) "title", NULL
35000 };
35001
35002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35004 if (SWIG_arg_fail(1)) SWIG_fail;
35005 {
35006 arg2 = wxString_in_helper(obj1);
35007 if (arg2 == NULL) SWIG_fail;
35008 temp2 = true;
35009 }
35010 {
35011 PyThreadState* __tstate = wxPyBeginAllowThreads();
35012 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35013
35014 wxPyEndAllowThreads(__tstate);
35015 if (PyErr_Occurred()) SWIG_fail;
35016 }
35017 {
35018 resultobj = SWIG_From_int((int)(result));
35019 }
35020 {
35021 if (temp2)
35022 delete arg2;
35023 }
35024 return resultobj;
35025 fail:
35026 {
35027 if (temp2)
35028 delete arg2;
35029 }
35030 return NULL;
35031 }
35032
35033
35034 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35035 PyObject *resultobj;
35036 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35037 int arg2 ;
35038 bool arg3 ;
35039 PyObject * obj0 = 0 ;
35040 PyObject * obj1 = 0 ;
35041 PyObject * obj2 = 0 ;
35042 char *kwnames[] = {
35043 (char *) "self",(char *) "id",(char *) "enable", NULL
35044 };
35045
35046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35048 if (SWIG_arg_fail(1)) SWIG_fail;
35049 {
35050 arg2 = (int)(SWIG_As_int(obj1));
35051 if (SWIG_arg_fail(2)) SWIG_fail;
35052 }
35053 {
35054 arg3 = (bool)(SWIG_As_bool(obj2));
35055 if (SWIG_arg_fail(3)) SWIG_fail;
35056 }
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 (arg1)->Enable(arg2,arg3);
35060
35061 wxPyEndAllowThreads(__tstate);
35062 if (PyErr_Occurred()) SWIG_fail;
35063 }
35064 Py_INCREF(Py_None); resultobj = Py_None;
35065 return resultobj;
35066 fail:
35067 return NULL;
35068 }
35069
35070
35071 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35072 PyObject *resultobj;
35073 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35074 int arg2 ;
35075 bool arg3 ;
35076 PyObject * obj0 = 0 ;
35077 PyObject * obj1 = 0 ;
35078 PyObject * obj2 = 0 ;
35079 char *kwnames[] = {
35080 (char *) "self",(char *) "id",(char *) "check", NULL
35081 };
35082
35083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35085 if (SWIG_arg_fail(1)) SWIG_fail;
35086 {
35087 arg2 = (int)(SWIG_As_int(obj1));
35088 if (SWIG_arg_fail(2)) SWIG_fail;
35089 }
35090 {
35091 arg3 = (bool)(SWIG_As_bool(obj2));
35092 if (SWIG_arg_fail(3)) SWIG_fail;
35093 }
35094 {
35095 PyThreadState* __tstate = wxPyBeginAllowThreads();
35096 (arg1)->Check(arg2,arg3);
35097
35098 wxPyEndAllowThreads(__tstate);
35099 if (PyErr_Occurred()) SWIG_fail;
35100 }
35101 Py_INCREF(Py_None); resultobj = Py_None;
35102 return resultobj;
35103 fail:
35104 return NULL;
35105 }
35106
35107
35108 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35109 PyObject *resultobj;
35110 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35111 int arg2 ;
35112 bool result;
35113 PyObject * obj0 = 0 ;
35114 PyObject * obj1 = 0 ;
35115 char *kwnames[] = {
35116 (char *) "self",(char *) "id", NULL
35117 };
35118
35119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35121 if (SWIG_arg_fail(1)) SWIG_fail;
35122 {
35123 arg2 = (int)(SWIG_As_int(obj1));
35124 if (SWIG_arg_fail(2)) SWIG_fail;
35125 }
35126 {
35127 PyThreadState* __tstate = wxPyBeginAllowThreads();
35128 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35129
35130 wxPyEndAllowThreads(__tstate);
35131 if (PyErr_Occurred()) SWIG_fail;
35132 }
35133 {
35134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35135 }
35136 return resultobj;
35137 fail:
35138 return NULL;
35139 }
35140
35141
35142 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35143 PyObject *resultobj;
35144 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35145 int arg2 ;
35146 bool result;
35147 PyObject * obj0 = 0 ;
35148 PyObject * obj1 = 0 ;
35149 char *kwnames[] = {
35150 (char *) "self",(char *) "id", NULL
35151 };
35152
35153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35155 if (SWIG_arg_fail(1)) SWIG_fail;
35156 {
35157 arg2 = (int)(SWIG_As_int(obj1));
35158 if (SWIG_arg_fail(2)) SWIG_fail;
35159 }
35160 {
35161 PyThreadState* __tstate = wxPyBeginAllowThreads();
35162 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35163
35164 wxPyEndAllowThreads(__tstate);
35165 if (PyErr_Occurred()) SWIG_fail;
35166 }
35167 {
35168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35169 }
35170 return resultobj;
35171 fail:
35172 return NULL;
35173 }
35174
35175
35176 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35177 PyObject *resultobj;
35178 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35179 int arg2 ;
35180 wxString *arg3 = 0 ;
35181 bool temp3 = false ;
35182 PyObject * obj0 = 0 ;
35183 PyObject * obj1 = 0 ;
35184 PyObject * obj2 = 0 ;
35185 char *kwnames[] = {
35186 (char *) "self",(char *) "id",(char *) "label", NULL
35187 };
35188
35189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35191 if (SWIG_arg_fail(1)) SWIG_fail;
35192 {
35193 arg2 = (int)(SWIG_As_int(obj1));
35194 if (SWIG_arg_fail(2)) SWIG_fail;
35195 }
35196 {
35197 arg3 = wxString_in_helper(obj2);
35198 if (arg3 == NULL) SWIG_fail;
35199 temp3 = true;
35200 }
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35204
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 Py_INCREF(Py_None); resultobj = Py_None;
35209 {
35210 if (temp3)
35211 delete arg3;
35212 }
35213 return resultobj;
35214 fail:
35215 {
35216 if (temp3)
35217 delete arg3;
35218 }
35219 return NULL;
35220 }
35221
35222
35223 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35224 PyObject *resultobj;
35225 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35226 int arg2 ;
35227 wxString result;
35228 PyObject * obj0 = 0 ;
35229 PyObject * obj1 = 0 ;
35230 char *kwnames[] = {
35231 (char *) "self",(char *) "id", NULL
35232 };
35233
35234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35236 if (SWIG_arg_fail(1)) SWIG_fail;
35237 {
35238 arg2 = (int)(SWIG_As_int(obj1));
35239 if (SWIG_arg_fail(2)) SWIG_fail;
35240 }
35241 {
35242 PyThreadState* __tstate = wxPyBeginAllowThreads();
35243 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35244
35245 wxPyEndAllowThreads(__tstate);
35246 if (PyErr_Occurred()) SWIG_fail;
35247 }
35248 {
35249 #if wxUSE_UNICODE
35250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35251 #else
35252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35253 #endif
35254 }
35255 return resultobj;
35256 fail:
35257 return NULL;
35258 }
35259
35260
35261 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35262 PyObject *resultobj;
35263 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35264 int arg2 ;
35265 wxString *arg3 = 0 ;
35266 bool temp3 = false ;
35267 PyObject * obj0 = 0 ;
35268 PyObject * obj1 = 0 ;
35269 PyObject * obj2 = 0 ;
35270 char *kwnames[] = {
35271 (char *) "self",(char *) "id",(char *) "helpString", NULL
35272 };
35273
35274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35276 if (SWIG_arg_fail(1)) SWIG_fail;
35277 {
35278 arg2 = (int)(SWIG_As_int(obj1));
35279 if (SWIG_arg_fail(2)) SWIG_fail;
35280 }
35281 {
35282 arg3 = wxString_in_helper(obj2);
35283 if (arg3 == NULL) SWIG_fail;
35284 temp3 = true;
35285 }
35286 {
35287 PyThreadState* __tstate = wxPyBeginAllowThreads();
35288 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35289
35290 wxPyEndAllowThreads(__tstate);
35291 if (PyErr_Occurred()) SWIG_fail;
35292 }
35293 Py_INCREF(Py_None); resultobj = Py_None;
35294 {
35295 if (temp3)
35296 delete arg3;
35297 }
35298 return resultobj;
35299 fail:
35300 {
35301 if (temp3)
35302 delete arg3;
35303 }
35304 return NULL;
35305 }
35306
35307
35308 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35309 PyObject *resultobj;
35310 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35311 int arg2 ;
35312 wxString result;
35313 PyObject * obj0 = 0 ;
35314 PyObject * obj1 = 0 ;
35315 char *kwnames[] = {
35316 (char *) "self",(char *) "id", NULL
35317 };
35318
35319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35321 if (SWIG_arg_fail(1)) SWIG_fail;
35322 {
35323 arg2 = (int)(SWIG_As_int(obj1));
35324 if (SWIG_arg_fail(2)) SWIG_fail;
35325 }
35326 {
35327 PyThreadState* __tstate = wxPyBeginAllowThreads();
35328 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35329
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 {
35334 #if wxUSE_UNICODE
35335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35336 #else
35337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35338 #endif
35339 }
35340 return resultobj;
35341 fail:
35342 return NULL;
35343 }
35344
35345
35346 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35347 PyObject *resultobj;
35348 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35349 wxFrame *result;
35350 PyObject * obj0 = 0 ;
35351 char *kwnames[] = {
35352 (char *) "self", NULL
35353 };
35354
35355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35357 if (SWIG_arg_fail(1)) SWIG_fail;
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35361
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 {
35366 resultobj = wxPyMake_wxObject(result, 0);
35367 }
35368 return resultobj;
35369 fail:
35370 return NULL;
35371 }
35372
35373
35374 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35375 PyObject *resultobj;
35376 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35377 bool result;
35378 PyObject * obj0 = 0 ;
35379 char *kwnames[] = {
35380 (char *) "self", NULL
35381 };
35382
35383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
35388 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35389
35390 wxPyEndAllowThreads(__tstate);
35391 if (PyErr_Occurred()) SWIG_fail;
35392 }
35393 {
35394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35395 }
35396 return resultobj;
35397 fail:
35398 return NULL;
35399 }
35400
35401
35402 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35403 PyObject *resultobj;
35404 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35405 wxFrame *arg2 = (wxFrame *) 0 ;
35406 PyObject * obj0 = 0 ;
35407 PyObject * obj1 = 0 ;
35408 char *kwnames[] = {
35409 (char *) "self",(char *) "frame", NULL
35410 };
35411
35412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35414 if (SWIG_arg_fail(1)) SWIG_fail;
35415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35416 if (SWIG_arg_fail(2)) SWIG_fail;
35417 {
35418 PyThreadState* __tstate = wxPyBeginAllowThreads();
35419 (arg1)->Attach(arg2);
35420
35421 wxPyEndAllowThreads(__tstate);
35422 if (PyErr_Occurred()) SWIG_fail;
35423 }
35424 Py_INCREF(Py_None); resultobj = Py_None;
35425 return resultobj;
35426 fail:
35427 return NULL;
35428 }
35429
35430
35431 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35432 PyObject *resultobj;
35433 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35434 PyObject * obj0 = 0 ;
35435 char *kwnames[] = {
35436 (char *) "self", NULL
35437 };
35438
35439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35441 if (SWIG_arg_fail(1)) SWIG_fail;
35442 {
35443 PyThreadState* __tstate = wxPyBeginAllowThreads();
35444 (arg1)->Detach();
35445
35446 wxPyEndAllowThreads(__tstate);
35447 if (PyErr_Occurred()) SWIG_fail;
35448 }
35449 Py_INCREF(Py_None); resultobj = Py_None;
35450 return resultobj;
35451 fail:
35452 return NULL;
35453 }
35454
35455
35456 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35457 PyObject *obj;
35458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35459 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35460 Py_INCREF(obj);
35461 return Py_BuildValue((char *)"");
35462 }
35463 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35464 PyObject *resultobj;
35465 wxMenu *arg1 = (wxMenu *) NULL ;
35466 int arg2 = (int) wxID_ANY ;
35467 wxString const &arg3_defvalue = wxPyEmptyString ;
35468 wxString *arg3 = (wxString *) &arg3_defvalue ;
35469 wxString const &arg4_defvalue = wxPyEmptyString ;
35470 wxString *arg4 = (wxString *) &arg4_defvalue ;
35471 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35472 wxMenu *arg6 = (wxMenu *) NULL ;
35473 wxMenuItem *result;
35474 bool temp3 = false ;
35475 bool temp4 = false ;
35476 PyObject * obj0 = 0 ;
35477 PyObject * obj1 = 0 ;
35478 PyObject * obj2 = 0 ;
35479 PyObject * obj3 = 0 ;
35480 PyObject * obj4 = 0 ;
35481 PyObject * obj5 = 0 ;
35482 char *kwnames[] = {
35483 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35484 };
35485
35486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35487 if (obj0) {
35488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35489 if (SWIG_arg_fail(1)) SWIG_fail;
35490 }
35491 if (obj1) {
35492 {
35493 arg2 = (int)(SWIG_As_int(obj1));
35494 if (SWIG_arg_fail(2)) SWIG_fail;
35495 }
35496 }
35497 if (obj2) {
35498 {
35499 arg3 = wxString_in_helper(obj2);
35500 if (arg3 == NULL) SWIG_fail;
35501 temp3 = true;
35502 }
35503 }
35504 if (obj3) {
35505 {
35506 arg4 = wxString_in_helper(obj3);
35507 if (arg4 == NULL) SWIG_fail;
35508 temp4 = true;
35509 }
35510 }
35511 if (obj4) {
35512 {
35513 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35514 if (SWIG_arg_fail(5)) SWIG_fail;
35515 }
35516 }
35517 if (obj5) {
35518 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35519 if (SWIG_arg_fail(6)) SWIG_fail;
35520 }
35521 {
35522 PyThreadState* __tstate = wxPyBeginAllowThreads();
35523 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35524
35525 wxPyEndAllowThreads(__tstate);
35526 if (PyErr_Occurred()) SWIG_fail;
35527 }
35528 {
35529 resultobj = wxPyMake_wxObject(result, 1);
35530 }
35531 {
35532 if (temp3)
35533 delete arg3;
35534 }
35535 {
35536 if (temp4)
35537 delete arg4;
35538 }
35539 return resultobj;
35540 fail:
35541 {
35542 if (temp3)
35543 delete arg3;
35544 }
35545 {
35546 if (temp4)
35547 delete arg4;
35548 }
35549 return NULL;
35550 }
35551
35552
35553 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35554 PyObject *resultobj;
35555 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35556 wxMenu *result;
35557 PyObject * obj0 = 0 ;
35558 char *kwnames[] = {
35559 (char *) "self", NULL
35560 };
35561
35562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35564 if (SWIG_arg_fail(1)) SWIG_fail;
35565 {
35566 PyThreadState* __tstate = wxPyBeginAllowThreads();
35567 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35568
35569 wxPyEndAllowThreads(__tstate);
35570 if (PyErr_Occurred()) SWIG_fail;
35571 }
35572 {
35573 resultobj = wxPyMake_wxObject(result, 0);
35574 }
35575 return resultobj;
35576 fail:
35577 return NULL;
35578 }
35579
35580
35581 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35582 PyObject *resultobj;
35583 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35584 wxMenu *arg2 = (wxMenu *) 0 ;
35585 PyObject * obj0 = 0 ;
35586 PyObject * obj1 = 0 ;
35587 char *kwnames[] = {
35588 (char *) "self",(char *) "menu", NULL
35589 };
35590
35591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35593 if (SWIG_arg_fail(1)) SWIG_fail;
35594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35595 if (SWIG_arg_fail(2)) SWIG_fail;
35596 {
35597 PyThreadState* __tstate = wxPyBeginAllowThreads();
35598 (arg1)->SetMenu(arg2);
35599
35600 wxPyEndAllowThreads(__tstate);
35601 if (PyErr_Occurred()) SWIG_fail;
35602 }
35603 Py_INCREF(Py_None); resultobj = Py_None;
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35611 PyObject *resultobj;
35612 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35613 int arg2 ;
35614 PyObject * obj0 = 0 ;
35615 PyObject * obj1 = 0 ;
35616 char *kwnames[] = {
35617 (char *) "self",(char *) "id", NULL
35618 };
35619
35620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35622 if (SWIG_arg_fail(1)) SWIG_fail;
35623 {
35624 arg2 = (int)(SWIG_As_int(obj1));
35625 if (SWIG_arg_fail(2)) SWIG_fail;
35626 }
35627 {
35628 PyThreadState* __tstate = wxPyBeginAllowThreads();
35629 (arg1)->SetId(arg2);
35630
35631 wxPyEndAllowThreads(__tstate);
35632 if (PyErr_Occurred()) SWIG_fail;
35633 }
35634 Py_INCREF(Py_None); resultobj = Py_None;
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35642 PyObject *resultobj;
35643 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35644 int result;
35645 PyObject * obj0 = 0 ;
35646 char *kwnames[] = {
35647 (char *) "self", NULL
35648 };
35649
35650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35652 if (SWIG_arg_fail(1)) SWIG_fail;
35653 {
35654 PyThreadState* __tstate = wxPyBeginAllowThreads();
35655 result = (int)((wxMenuItem const *)arg1)->GetId();
35656
35657 wxPyEndAllowThreads(__tstate);
35658 if (PyErr_Occurred()) SWIG_fail;
35659 }
35660 {
35661 resultobj = SWIG_From_int((int)(result));
35662 }
35663 return resultobj;
35664 fail:
35665 return NULL;
35666 }
35667
35668
35669 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35670 PyObject *resultobj;
35671 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35672 bool result;
35673 PyObject * obj0 = 0 ;
35674 char *kwnames[] = {
35675 (char *) "self", NULL
35676 };
35677
35678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35680 if (SWIG_arg_fail(1)) SWIG_fail;
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35684
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 {
35689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35690 }
35691 return resultobj;
35692 fail:
35693 return NULL;
35694 }
35695
35696
35697 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35698 PyObject *resultobj;
35699 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35700 wxString *arg2 = 0 ;
35701 bool temp2 = false ;
35702 PyObject * obj0 = 0 ;
35703 PyObject * obj1 = 0 ;
35704 char *kwnames[] = {
35705 (char *) "self",(char *) "str", NULL
35706 };
35707
35708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35710 if (SWIG_arg_fail(1)) SWIG_fail;
35711 {
35712 arg2 = wxString_in_helper(obj1);
35713 if (arg2 == NULL) SWIG_fail;
35714 temp2 = true;
35715 }
35716 {
35717 PyThreadState* __tstate = wxPyBeginAllowThreads();
35718 (arg1)->SetText((wxString const &)*arg2);
35719
35720 wxPyEndAllowThreads(__tstate);
35721 if (PyErr_Occurred()) SWIG_fail;
35722 }
35723 Py_INCREF(Py_None); resultobj = Py_None;
35724 {
35725 if (temp2)
35726 delete arg2;
35727 }
35728 return resultobj;
35729 fail:
35730 {
35731 if (temp2)
35732 delete arg2;
35733 }
35734 return NULL;
35735 }
35736
35737
35738 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35739 PyObject *resultobj;
35740 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35741 wxString result;
35742 PyObject * obj0 = 0 ;
35743 char *kwnames[] = {
35744 (char *) "self", NULL
35745 };
35746
35747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35749 if (SWIG_arg_fail(1)) SWIG_fail;
35750 {
35751 PyThreadState* __tstate = wxPyBeginAllowThreads();
35752 result = ((wxMenuItem const *)arg1)->GetLabel();
35753
35754 wxPyEndAllowThreads(__tstate);
35755 if (PyErr_Occurred()) SWIG_fail;
35756 }
35757 {
35758 #if wxUSE_UNICODE
35759 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35760 #else
35761 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35762 #endif
35763 }
35764 return resultobj;
35765 fail:
35766 return NULL;
35767 }
35768
35769
35770 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35771 PyObject *resultobj;
35772 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35773 wxString *result;
35774 PyObject * obj0 = 0 ;
35775 char *kwnames[] = {
35776 (char *) "self", NULL
35777 };
35778
35779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35781 if (SWIG_arg_fail(1)) SWIG_fail;
35782 {
35783 PyThreadState* __tstate = wxPyBeginAllowThreads();
35784 {
35785 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35786 result = (wxString *) &_result_ref;
35787 }
35788
35789 wxPyEndAllowThreads(__tstate);
35790 if (PyErr_Occurred()) SWIG_fail;
35791 }
35792 {
35793 #if wxUSE_UNICODE
35794 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35795 #else
35796 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35797 #endif
35798 }
35799 return resultobj;
35800 fail:
35801 return NULL;
35802 }
35803
35804
35805 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35806 PyObject *resultobj;
35807 wxString *arg1 = 0 ;
35808 wxString result;
35809 bool temp1 = false ;
35810 PyObject * obj0 = 0 ;
35811 char *kwnames[] = {
35812 (char *) "text", NULL
35813 };
35814
35815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35816 {
35817 arg1 = wxString_in_helper(obj0);
35818 if (arg1 == NULL) SWIG_fail;
35819 temp1 = true;
35820 }
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35824
35825 wxPyEndAllowThreads(__tstate);
35826 if (PyErr_Occurred()) SWIG_fail;
35827 }
35828 {
35829 #if wxUSE_UNICODE
35830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35831 #else
35832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35833 #endif
35834 }
35835 {
35836 if (temp1)
35837 delete arg1;
35838 }
35839 return resultobj;
35840 fail:
35841 {
35842 if (temp1)
35843 delete arg1;
35844 }
35845 return NULL;
35846 }
35847
35848
35849 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35850 PyObject *resultobj;
35851 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35852 wxItemKind result;
35853 PyObject * obj0 = 0 ;
35854 char *kwnames[] = {
35855 (char *) "self", NULL
35856 };
35857
35858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35860 if (SWIG_arg_fail(1)) SWIG_fail;
35861 {
35862 PyThreadState* __tstate = wxPyBeginAllowThreads();
35863 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35864
35865 wxPyEndAllowThreads(__tstate);
35866 if (PyErr_Occurred()) SWIG_fail;
35867 }
35868 resultobj = SWIG_From_int((result));
35869 return resultobj;
35870 fail:
35871 return NULL;
35872 }
35873
35874
35875 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35876 PyObject *resultobj;
35877 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35878 wxItemKind arg2 ;
35879 PyObject * obj0 = 0 ;
35880 PyObject * obj1 = 0 ;
35881 char *kwnames[] = {
35882 (char *) "self",(char *) "kind", NULL
35883 };
35884
35885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35887 if (SWIG_arg_fail(1)) SWIG_fail;
35888 {
35889 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35890 if (SWIG_arg_fail(2)) SWIG_fail;
35891 }
35892 {
35893 PyThreadState* __tstate = wxPyBeginAllowThreads();
35894 (arg1)->SetKind((wxItemKind )arg2);
35895
35896 wxPyEndAllowThreads(__tstate);
35897 if (PyErr_Occurred()) SWIG_fail;
35898 }
35899 Py_INCREF(Py_None); resultobj = Py_None;
35900 return resultobj;
35901 fail:
35902 return NULL;
35903 }
35904
35905
35906 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35907 PyObject *resultobj;
35908 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35909 bool arg2 ;
35910 PyObject * obj0 = 0 ;
35911 PyObject * obj1 = 0 ;
35912 char *kwnames[] = {
35913 (char *) "self",(char *) "checkable", NULL
35914 };
35915
35916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35918 if (SWIG_arg_fail(1)) SWIG_fail;
35919 {
35920 arg2 = (bool)(SWIG_As_bool(obj1));
35921 if (SWIG_arg_fail(2)) SWIG_fail;
35922 }
35923 {
35924 PyThreadState* __tstate = wxPyBeginAllowThreads();
35925 (arg1)->SetCheckable(arg2);
35926
35927 wxPyEndAllowThreads(__tstate);
35928 if (PyErr_Occurred()) SWIG_fail;
35929 }
35930 Py_INCREF(Py_None); resultobj = Py_None;
35931 return resultobj;
35932 fail:
35933 return NULL;
35934 }
35935
35936
35937 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35938 PyObject *resultobj;
35939 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35940 bool result;
35941 PyObject * obj0 = 0 ;
35942 char *kwnames[] = {
35943 (char *) "self", NULL
35944 };
35945
35946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35948 if (SWIG_arg_fail(1)) SWIG_fail;
35949 {
35950 PyThreadState* __tstate = wxPyBeginAllowThreads();
35951 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35952
35953 wxPyEndAllowThreads(__tstate);
35954 if (PyErr_Occurred()) SWIG_fail;
35955 }
35956 {
35957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35958 }
35959 return resultobj;
35960 fail:
35961 return NULL;
35962 }
35963
35964
35965 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35966 PyObject *resultobj;
35967 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35968 bool result;
35969 PyObject * obj0 = 0 ;
35970 char *kwnames[] = {
35971 (char *) "self", NULL
35972 };
35973
35974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35976 if (SWIG_arg_fail(1)) SWIG_fail;
35977 {
35978 PyThreadState* __tstate = wxPyBeginAllowThreads();
35979 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35980
35981 wxPyEndAllowThreads(__tstate);
35982 if (PyErr_Occurred()) SWIG_fail;
35983 }
35984 {
35985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35986 }
35987 return resultobj;
35988 fail:
35989 return NULL;
35990 }
35991
35992
35993 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35994 PyObject *resultobj;
35995 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35996 wxMenu *arg2 = (wxMenu *) 0 ;
35997 PyObject * obj0 = 0 ;
35998 PyObject * obj1 = 0 ;
35999 char *kwnames[] = {
36000 (char *) "self",(char *) "menu", NULL
36001 };
36002
36003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36005 if (SWIG_arg_fail(1)) SWIG_fail;
36006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36007 if (SWIG_arg_fail(2)) SWIG_fail;
36008 {
36009 PyThreadState* __tstate = wxPyBeginAllowThreads();
36010 (arg1)->SetSubMenu(arg2);
36011
36012 wxPyEndAllowThreads(__tstate);
36013 if (PyErr_Occurred()) SWIG_fail;
36014 }
36015 Py_INCREF(Py_None); resultobj = Py_None;
36016 return resultobj;
36017 fail:
36018 return NULL;
36019 }
36020
36021
36022 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36023 PyObject *resultobj;
36024 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36025 wxMenu *result;
36026 PyObject * obj0 = 0 ;
36027 char *kwnames[] = {
36028 (char *) "self", NULL
36029 };
36030
36031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36033 if (SWIG_arg_fail(1)) SWIG_fail;
36034 {
36035 PyThreadState* __tstate = wxPyBeginAllowThreads();
36036 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36037
36038 wxPyEndAllowThreads(__tstate);
36039 if (PyErr_Occurred()) SWIG_fail;
36040 }
36041 {
36042 resultobj = wxPyMake_wxObject(result, 0);
36043 }
36044 return resultobj;
36045 fail:
36046 return NULL;
36047 }
36048
36049
36050 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36051 PyObject *resultobj;
36052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36053 bool arg2 = (bool) true ;
36054 PyObject * obj0 = 0 ;
36055 PyObject * obj1 = 0 ;
36056 char *kwnames[] = {
36057 (char *) "self",(char *) "enable", NULL
36058 };
36059
36060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36062 if (SWIG_arg_fail(1)) SWIG_fail;
36063 if (obj1) {
36064 {
36065 arg2 = (bool)(SWIG_As_bool(obj1));
36066 if (SWIG_arg_fail(2)) SWIG_fail;
36067 }
36068 }
36069 {
36070 PyThreadState* __tstate = wxPyBeginAllowThreads();
36071 (arg1)->Enable(arg2);
36072
36073 wxPyEndAllowThreads(__tstate);
36074 if (PyErr_Occurred()) SWIG_fail;
36075 }
36076 Py_INCREF(Py_None); resultobj = Py_None;
36077 return resultobj;
36078 fail:
36079 return NULL;
36080 }
36081
36082
36083 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36084 PyObject *resultobj;
36085 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36086 bool result;
36087 PyObject * obj0 = 0 ;
36088 char *kwnames[] = {
36089 (char *) "self", NULL
36090 };
36091
36092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36094 if (SWIG_arg_fail(1)) SWIG_fail;
36095 {
36096 PyThreadState* __tstate = wxPyBeginAllowThreads();
36097 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36098
36099 wxPyEndAllowThreads(__tstate);
36100 if (PyErr_Occurred()) SWIG_fail;
36101 }
36102 {
36103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36104 }
36105 return resultobj;
36106 fail:
36107 return NULL;
36108 }
36109
36110
36111 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36112 PyObject *resultobj;
36113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36114 bool arg2 = (bool) true ;
36115 PyObject * obj0 = 0 ;
36116 PyObject * obj1 = 0 ;
36117 char *kwnames[] = {
36118 (char *) "self",(char *) "check", NULL
36119 };
36120
36121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36123 if (SWIG_arg_fail(1)) SWIG_fail;
36124 if (obj1) {
36125 {
36126 arg2 = (bool)(SWIG_As_bool(obj1));
36127 if (SWIG_arg_fail(2)) SWIG_fail;
36128 }
36129 }
36130 {
36131 PyThreadState* __tstate = wxPyBeginAllowThreads();
36132 (arg1)->Check(arg2);
36133
36134 wxPyEndAllowThreads(__tstate);
36135 if (PyErr_Occurred()) SWIG_fail;
36136 }
36137 Py_INCREF(Py_None); resultobj = Py_None;
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36145 PyObject *resultobj;
36146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36147 bool result;
36148 PyObject * obj0 = 0 ;
36149 char *kwnames[] = {
36150 (char *) "self", NULL
36151 };
36152
36153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36155 if (SWIG_arg_fail(1)) SWIG_fail;
36156 {
36157 PyThreadState* __tstate = wxPyBeginAllowThreads();
36158 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36159
36160 wxPyEndAllowThreads(__tstate);
36161 if (PyErr_Occurred()) SWIG_fail;
36162 }
36163 {
36164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36165 }
36166 return resultobj;
36167 fail:
36168 return NULL;
36169 }
36170
36171
36172 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36173 PyObject *resultobj;
36174 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36175 PyObject * obj0 = 0 ;
36176 char *kwnames[] = {
36177 (char *) "self", NULL
36178 };
36179
36180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36182 if (SWIG_arg_fail(1)) SWIG_fail;
36183 {
36184 PyThreadState* __tstate = wxPyBeginAllowThreads();
36185 (arg1)->Toggle();
36186
36187 wxPyEndAllowThreads(__tstate);
36188 if (PyErr_Occurred()) SWIG_fail;
36189 }
36190 Py_INCREF(Py_None); resultobj = Py_None;
36191 return resultobj;
36192 fail:
36193 return NULL;
36194 }
36195
36196
36197 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36198 PyObject *resultobj;
36199 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36200 wxString *arg2 = 0 ;
36201 bool temp2 = false ;
36202 PyObject * obj0 = 0 ;
36203 PyObject * obj1 = 0 ;
36204 char *kwnames[] = {
36205 (char *) "self",(char *) "str", NULL
36206 };
36207
36208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36210 if (SWIG_arg_fail(1)) SWIG_fail;
36211 {
36212 arg2 = wxString_in_helper(obj1);
36213 if (arg2 == NULL) SWIG_fail;
36214 temp2 = true;
36215 }
36216 {
36217 PyThreadState* __tstate = wxPyBeginAllowThreads();
36218 (arg1)->SetHelp((wxString const &)*arg2);
36219
36220 wxPyEndAllowThreads(__tstate);
36221 if (PyErr_Occurred()) SWIG_fail;
36222 }
36223 Py_INCREF(Py_None); resultobj = Py_None;
36224 {
36225 if (temp2)
36226 delete arg2;
36227 }
36228 return resultobj;
36229 fail:
36230 {
36231 if (temp2)
36232 delete arg2;
36233 }
36234 return NULL;
36235 }
36236
36237
36238 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36239 PyObject *resultobj;
36240 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36241 wxString *result;
36242 PyObject * obj0 = 0 ;
36243 char *kwnames[] = {
36244 (char *) "self", NULL
36245 };
36246
36247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36249 if (SWIG_arg_fail(1)) SWIG_fail;
36250 {
36251 PyThreadState* __tstate = wxPyBeginAllowThreads();
36252 {
36253 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36254 result = (wxString *) &_result_ref;
36255 }
36256
36257 wxPyEndAllowThreads(__tstate);
36258 if (PyErr_Occurred()) SWIG_fail;
36259 }
36260 {
36261 #if wxUSE_UNICODE
36262 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36263 #else
36264 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36265 #endif
36266 }
36267 return resultobj;
36268 fail:
36269 return NULL;
36270 }
36271
36272
36273 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36274 PyObject *resultobj;
36275 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36276 wxAcceleratorEntry *result;
36277 PyObject * obj0 = 0 ;
36278 char *kwnames[] = {
36279 (char *) "self", NULL
36280 };
36281
36282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36284 if (SWIG_arg_fail(1)) SWIG_fail;
36285 {
36286 PyThreadState* __tstate = wxPyBeginAllowThreads();
36287 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36288
36289 wxPyEndAllowThreads(__tstate);
36290 if (PyErr_Occurred()) SWIG_fail;
36291 }
36292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36293 return resultobj;
36294 fail:
36295 return NULL;
36296 }
36297
36298
36299 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36300 PyObject *resultobj;
36301 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36302 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36303 PyObject * obj0 = 0 ;
36304 PyObject * obj1 = 0 ;
36305 char *kwnames[] = {
36306 (char *) "self",(char *) "accel", NULL
36307 };
36308
36309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36311 if (SWIG_arg_fail(1)) SWIG_fail;
36312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36313 if (SWIG_arg_fail(2)) SWIG_fail;
36314 {
36315 PyThreadState* __tstate = wxPyBeginAllowThreads();
36316 (arg1)->SetAccel(arg2);
36317
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 Py_INCREF(Py_None); resultobj = Py_None;
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36329 PyObject *resultobj;
36330 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36331 wxFont *arg2 = 0 ;
36332 PyObject * obj0 = 0 ;
36333 PyObject * obj1 = 0 ;
36334 char *kwnames[] = {
36335 (char *) "self",(char *) "font", NULL
36336 };
36337
36338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36340 if (SWIG_arg_fail(1)) SWIG_fail;
36341 {
36342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36343 if (SWIG_arg_fail(2)) SWIG_fail;
36344 if (arg2 == NULL) {
36345 SWIG_null_ref("wxFont");
36346 }
36347 if (SWIG_arg_fail(2)) SWIG_fail;
36348 }
36349 {
36350 PyThreadState* __tstate = wxPyBeginAllowThreads();
36351 (arg1)->SetFont((wxFont const &)*arg2);
36352
36353 wxPyEndAllowThreads(__tstate);
36354 if (PyErr_Occurred()) SWIG_fail;
36355 }
36356 Py_INCREF(Py_None); resultobj = Py_None;
36357 return resultobj;
36358 fail:
36359 return NULL;
36360 }
36361
36362
36363 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36364 PyObject *resultobj;
36365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36366 wxFont result;
36367 PyObject * obj0 = 0 ;
36368 char *kwnames[] = {
36369 (char *) "self", NULL
36370 };
36371
36372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36374 if (SWIG_arg_fail(1)) SWIG_fail;
36375 {
36376 PyThreadState* __tstate = wxPyBeginAllowThreads();
36377 result = (arg1)->GetFont();
36378
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 {
36383 wxFont * resultptr;
36384 resultptr = new wxFont((wxFont &)(result));
36385 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36386 }
36387 return resultobj;
36388 fail:
36389 return NULL;
36390 }
36391
36392
36393 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36394 PyObject *resultobj;
36395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36396 wxColour *arg2 = 0 ;
36397 wxColour temp2 ;
36398 PyObject * obj0 = 0 ;
36399 PyObject * obj1 = 0 ;
36400 char *kwnames[] = {
36401 (char *) "self",(char *) "colText", NULL
36402 };
36403
36404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36406 if (SWIG_arg_fail(1)) SWIG_fail;
36407 {
36408 arg2 = &temp2;
36409 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36410 }
36411 {
36412 PyThreadState* __tstate = wxPyBeginAllowThreads();
36413 (arg1)->SetTextColour((wxColour const &)*arg2);
36414
36415 wxPyEndAllowThreads(__tstate);
36416 if (PyErr_Occurred()) SWIG_fail;
36417 }
36418 Py_INCREF(Py_None); resultobj = Py_None;
36419 return resultobj;
36420 fail:
36421 return NULL;
36422 }
36423
36424
36425 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36426 PyObject *resultobj;
36427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36428 wxColour result;
36429 PyObject * obj0 = 0 ;
36430 char *kwnames[] = {
36431 (char *) "self", NULL
36432 };
36433
36434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36436 if (SWIG_arg_fail(1)) SWIG_fail;
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 result = (arg1)->GetTextColour();
36440
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 {
36445 wxColour * resultptr;
36446 resultptr = new wxColour((wxColour &)(result));
36447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36448 }
36449 return resultobj;
36450 fail:
36451 return NULL;
36452 }
36453
36454
36455 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36456 PyObject *resultobj;
36457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36458 wxColour *arg2 = 0 ;
36459 wxColour temp2 ;
36460 PyObject * obj0 = 0 ;
36461 PyObject * obj1 = 0 ;
36462 char *kwnames[] = {
36463 (char *) "self",(char *) "colBack", NULL
36464 };
36465
36466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36468 if (SWIG_arg_fail(1)) SWIG_fail;
36469 {
36470 arg2 = &temp2;
36471 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36472 }
36473 {
36474 PyThreadState* __tstate = wxPyBeginAllowThreads();
36475 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36476
36477 wxPyEndAllowThreads(__tstate);
36478 if (PyErr_Occurred()) SWIG_fail;
36479 }
36480 Py_INCREF(Py_None); resultobj = Py_None;
36481 return resultobj;
36482 fail:
36483 return NULL;
36484 }
36485
36486
36487 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36488 PyObject *resultobj;
36489 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36490 wxColour result;
36491 PyObject * obj0 = 0 ;
36492 char *kwnames[] = {
36493 (char *) "self", NULL
36494 };
36495
36496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36498 if (SWIG_arg_fail(1)) SWIG_fail;
36499 {
36500 PyThreadState* __tstate = wxPyBeginAllowThreads();
36501 result = (arg1)->GetBackgroundColour();
36502
36503 wxPyEndAllowThreads(__tstate);
36504 if (PyErr_Occurred()) SWIG_fail;
36505 }
36506 {
36507 wxColour * resultptr;
36508 resultptr = new wxColour((wxColour &)(result));
36509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36510 }
36511 return resultobj;
36512 fail:
36513 return NULL;
36514 }
36515
36516
36517 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36518 PyObject *resultobj;
36519 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36520 wxBitmap *arg2 = 0 ;
36521 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36522 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36523 PyObject * obj0 = 0 ;
36524 PyObject * obj1 = 0 ;
36525 PyObject * obj2 = 0 ;
36526 char *kwnames[] = {
36527 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36528 };
36529
36530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36532 if (SWIG_arg_fail(1)) SWIG_fail;
36533 {
36534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36535 if (SWIG_arg_fail(2)) SWIG_fail;
36536 if (arg2 == NULL) {
36537 SWIG_null_ref("wxBitmap");
36538 }
36539 if (SWIG_arg_fail(2)) SWIG_fail;
36540 }
36541 if (obj2) {
36542 {
36543 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36544 if (SWIG_arg_fail(3)) SWIG_fail;
36545 if (arg3 == NULL) {
36546 SWIG_null_ref("wxBitmap");
36547 }
36548 if (SWIG_arg_fail(3)) SWIG_fail;
36549 }
36550 }
36551 {
36552 PyThreadState* __tstate = wxPyBeginAllowThreads();
36553 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36554
36555 wxPyEndAllowThreads(__tstate);
36556 if (PyErr_Occurred()) SWIG_fail;
36557 }
36558 Py_INCREF(Py_None); resultobj = Py_None;
36559 return resultobj;
36560 fail:
36561 return NULL;
36562 }
36563
36564
36565 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36566 PyObject *resultobj;
36567 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36568 wxBitmap *arg2 = 0 ;
36569 PyObject * obj0 = 0 ;
36570 PyObject * obj1 = 0 ;
36571 char *kwnames[] = {
36572 (char *) "self",(char *) "bmpDisabled", NULL
36573 };
36574
36575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36577 if (SWIG_arg_fail(1)) SWIG_fail;
36578 {
36579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36580 if (SWIG_arg_fail(2)) SWIG_fail;
36581 if (arg2 == NULL) {
36582 SWIG_null_ref("wxBitmap");
36583 }
36584 if (SWIG_arg_fail(2)) SWIG_fail;
36585 }
36586 {
36587 PyThreadState* __tstate = wxPyBeginAllowThreads();
36588 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36589
36590 wxPyEndAllowThreads(__tstate);
36591 if (PyErr_Occurred()) SWIG_fail;
36592 }
36593 Py_INCREF(Py_None); resultobj = Py_None;
36594 return resultobj;
36595 fail:
36596 return NULL;
36597 }
36598
36599
36600 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36601 PyObject *resultobj;
36602 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36603 wxBitmap *result;
36604 PyObject * obj0 = 0 ;
36605 char *kwnames[] = {
36606 (char *) "self", NULL
36607 };
36608
36609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36611 if (SWIG_arg_fail(1)) SWIG_fail;
36612 {
36613 PyThreadState* __tstate = wxPyBeginAllowThreads();
36614 {
36615 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36616 result = (wxBitmap *) &_result_ref;
36617 }
36618
36619 wxPyEndAllowThreads(__tstate);
36620 if (PyErr_Occurred()) SWIG_fail;
36621 }
36622 {
36623 wxBitmap* resultptr = new wxBitmap(*result);
36624 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36625 }
36626 return resultobj;
36627 fail:
36628 return NULL;
36629 }
36630
36631
36632 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36633 PyObject *resultobj;
36634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36635 int arg2 ;
36636 PyObject * obj0 = 0 ;
36637 PyObject * obj1 = 0 ;
36638 char *kwnames[] = {
36639 (char *) "self",(char *) "nWidth", NULL
36640 };
36641
36642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36644 if (SWIG_arg_fail(1)) SWIG_fail;
36645 {
36646 arg2 = (int)(SWIG_As_int(obj1));
36647 if (SWIG_arg_fail(2)) SWIG_fail;
36648 }
36649 {
36650 PyThreadState* __tstate = wxPyBeginAllowThreads();
36651 (arg1)->SetMarginWidth(arg2);
36652
36653 wxPyEndAllowThreads(__tstate);
36654 if (PyErr_Occurred()) SWIG_fail;
36655 }
36656 Py_INCREF(Py_None); resultobj = Py_None;
36657 return resultobj;
36658 fail:
36659 return NULL;
36660 }
36661
36662
36663 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36664 PyObject *resultobj;
36665 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36666 int result;
36667 PyObject * obj0 = 0 ;
36668 char *kwnames[] = {
36669 (char *) "self", NULL
36670 };
36671
36672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36674 if (SWIG_arg_fail(1)) SWIG_fail;
36675 {
36676 PyThreadState* __tstate = wxPyBeginAllowThreads();
36677 result = (int)(arg1)->GetMarginWidth();
36678
36679 wxPyEndAllowThreads(__tstate);
36680 if (PyErr_Occurred()) SWIG_fail;
36681 }
36682 {
36683 resultobj = SWIG_From_int((int)(result));
36684 }
36685 return resultobj;
36686 fail:
36687 return NULL;
36688 }
36689
36690
36691 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36692 PyObject *resultobj;
36693 int result;
36694 char *kwnames[] = {
36695 NULL
36696 };
36697
36698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36699 {
36700 PyThreadState* __tstate = wxPyBeginAllowThreads();
36701 result = (int)wxMenuItem::GetDefaultMarginWidth();
36702
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 {
36707 resultobj = SWIG_From_int((int)(result));
36708 }
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36716 PyObject *resultobj;
36717 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36718 bool result;
36719 PyObject * obj0 = 0 ;
36720 char *kwnames[] = {
36721 (char *) "self", NULL
36722 };
36723
36724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36726 if (SWIG_arg_fail(1)) SWIG_fail;
36727 {
36728 PyThreadState* __tstate = wxPyBeginAllowThreads();
36729 result = (bool)(arg1)->IsOwnerDrawn();
36730
36731 wxPyEndAllowThreads(__tstate);
36732 if (PyErr_Occurred()) SWIG_fail;
36733 }
36734 {
36735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36736 }
36737 return resultobj;
36738 fail:
36739 return NULL;
36740 }
36741
36742
36743 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36744 PyObject *resultobj;
36745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36746 bool arg2 = (bool) true ;
36747 PyObject * obj0 = 0 ;
36748 PyObject * obj1 = 0 ;
36749 char *kwnames[] = {
36750 (char *) "self",(char *) "ownerDrawn", NULL
36751 };
36752
36753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36755 if (SWIG_arg_fail(1)) SWIG_fail;
36756 if (obj1) {
36757 {
36758 arg2 = (bool)(SWIG_As_bool(obj1));
36759 if (SWIG_arg_fail(2)) SWIG_fail;
36760 }
36761 }
36762 {
36763 PyThreadState* __tstate = wxPyBeginAllowThreads();
36764 (arg1)->SetOwnerDrawn(arg2);
36765
36766 wxPyEndAllowThreads(__tstate);
36767 if (PyErr_Occurred()) SWIG_fail;
36768 }
36769 Py_INCREF(Py_None); resultobj = Py_None;
36770 return resultobj;
36771 fail:
36772 return NULL;
36773 }
36774
36775
36776 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36777 PyObject *resultobj;
36778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36779 PyObject * obj0 = 0 ;
36780 char *kwnames[] = {
36781 (char *) "self", NULL
36782 };
36783
36784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36786 if (SWIG_arg_fail(1)) SWIG_fail;
36787 {
36788 PyThreadState* __tstate = wxPyBeginAllowThreads();
36789 (arg1)->ResetOwnerDrawn();
36790
36791 wxPyEndAllowThreads(__tstate);
36792 if (PyErr_Occurred()) SWIG_fail;
36793 }
36794 Py_INCREF(Py_None); resultobj = Py_None;
36795 return resultobj;
36796 fail:
36797 return NULL;
36798 }
36799
36800
36801 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36802 PyObject *resultobj;
36803 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36804 wxBitmap *arg2 = 0 ;
36805 PyObject * obj0 = 0 ;
36806 PyObject * obj1 = 0 ;
36807 char *kwnames[] = {
36808 (char *) "self",(char *) "bitmap", NULL
36809 };
36810
36811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36813 if (SWIG_arg_fail(1)) SWIG_fail;
36814 {
36815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36816 if (SWIG_arg_fail(2)) SWIG_fail;
36817 if (arg2 == NULL) {
36818 SWIG_null_ref("wxBitmap");
36819 }
36820 if (SWIG_arg_fail(2)) SWIG_fail;
36821 }
36822 {
36823 PyThreadState* __tstate = wxPyBeginAllowThreads();
36824 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36825
36826 wxPyEndAllowThreads(__tstate);
36827 if (PyErr_Occurred()) SWIG_fail;
36828 }
36829 Py_INCREF(Py_None); resultobj = Py_None;
36830 return resultobj;
36831 fail:
36832 return NULL;
36833 }
36834
36835
36836 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36837 PyObject *resultobj;
36838 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36839 wxBitmap *result;
36840 PyObject * obj0 = 0 ;
36841 char *kwnames[] = {
36842 (char *) "self", NULL
36843 };
36844
36845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36847 if (SWIG_arg_fail(1)) SWIG_fail;
36848 {
36849 PyThreadState* __tstate = wxPyBeginAllowThreads();
36850 {
36851 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36852 result = (wxBitmap *) &_result_ref;
36853 }
36854
36855 wxPyEndAllowThreads(__tstate);
36856 if (PyErr_Occurred()) SWIG_fail;
36857 }
36858 {
36859 wxBitmap* resultptr = new wxBitmap(*result);
36860 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36861 }
36862 return resultobj;
36863 fail:
36864 return NULL;
36865 }
36866
36867
36868 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36869 PyObject *obj;
36870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36871 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36872 Py_INCREF(obj);
36873 return Py_BuildValue((char *)"");
36874 }
36875 static int _wrap_ControlNameStr_set(PyObject *) {
36876 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36877 return 1;
36878 }
36879
36880
36881 static PyObject *_wrap_ControlNameStr_get(void) {
36882 PyObject *pyobj;
36883
36884 {
36885 #if wxUSE_UNICODE
36886 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36887 #else
36888 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36889 #endif
36890 }
36891 return pyobj;
36892 }
36893
36894
36895 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36896 PyObject *resultobj;
36897 wxWindow *arg1 = (wxWindow *) 0 ;
36898 int arg2 = (int) -1 ;
36899 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36900 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36901 wxSize const &arg4_defvalue = wxDefaultSize ;
36902 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36903 long arg5 = (long) 0 ;
36904 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36905 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36906 wxString const &arg7_defvalue = wxPyControlNameStr ;
36907 wxString *arg7 = (wxString *) &arg7_defvalue ;
36908 wxControl *result;
36909 wxPoint temp3 ;
36910 wxSize temp4 ;
36911 bool temp7 = false ;
36912 PyObject * obj0 = 0 ;
36913 PyObject * obj1 = 0 ;
36914 PyObject * obj2 = 0 ;
36915 PyObject * obj3 = 0 ;
36916 PyObject * obj4 = 0 ;
36917 PyObject * obj5 = 0 ;
36918 PyObject * obj6 = 0 ;
36919 char *kwnames[] = {
36920 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36921 };
36922
36923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36925 if (SWIG_arg_fail(1)) SWIG_fail;
36926 if (obj1) {
36927 {
36928 arg2 = (int)(SWIG_As_int(obj1));
36929 if (SWIG_arg_fail(2)) SWIG_fail;
36930 }
36931 }
36932 if (obj2) {
36933 {
36934 arg3 = &temp3;
36935 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36936 }
36937 }
36938 if (obj3) {
36939 {
36940 arg4 = &temp4;
36941 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36942 }
36943 }
36944 if (obj4) {
36945 {
36946 arg5 = (long)(SWIG_As_long(obj4));
36947 if (SWIG_arg_fail(5)) SWIG_fail;
36948 }
36949 }
36950 if (obj5) {
36951 {
36952 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36953 if (SWIG_arg_fail(6)) SWIG_fail;
36954 if (arg6 == NULL) {
36955 SWIG_null_ref("wxValidator");
36956 }
36957 if (SWIG_arg_fail(6)) SWIG_fail;
36958 }
36959 }
36960 if (obj6) {
36961 {
36962 arg7 = wxString_in_helper(obj6);
36963 if (arg7 == NULL) SWIG_fail;
36964 temp7 = true;
36965 }
36966 }
36967 {
36968 if (!wxPyCheckForApp()) SWIG_fail;
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36971
36972 wxPyEndAllowThreads(__tstate);
36973 if (PyErr_Occurred()) SWIG_fail;
36974 }
36975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36976 {
36977 if (temp7)
36978 delete arg7;
36979 }
36980 return resultobj;
36981 fail:
36982 {
36983 if (temp7)
36984 delete arg7;
36985 }
36986 return NULL;
36987 }
36988
36989
36990 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36991 PyObject *resultobj;
36992 wxControl *result;
36993 char *kwnames[] = {
36994 NULL
36995 };
36996
36997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36998 {
36999 if (!wxPyCheckForApp()) SWIG_fail;
37000 PyThreadState* __tstate = wxPyBeginAllowThreads();
37001 result = (wxControl *)new wxControl();
37002
37003 wxPyEndAllowThreads(__tstate);
37004 if (PyErr_Occurred()) SWIG_fail;
37005 }
37006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37014 PyObject *resultobj;
37015 wxControl *arg1 = (wxControl *) 0 ;
37016 wxWindow *arg2 = (wxWindow *) 0 ;
37017 int arg3 = (int) -1 ;
37018 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37019 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37020 wxSize const &arg5_defvalue = wxDefaultSize ;
37021 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37022 long arg6 = (long) 0 ;
37023 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37024 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37025 wxString const &arg8_defvalue = wxPyControlNameStr ;
37026 wxString *arg8 = (wxString *) &arg8_defvalue ;
37027 bool result;
37028 wxPoint temp4 ;
37029 wxSize temp5 ;
37030 bool temp8 = false ;
37031 PyObject * obj0 = 0 ;
37032 PyObject * obj1 = 0 ;
37033 PyObject * obj2 = 0 ;
37034 PyObject * obj3 = 0 ;
37035 PyObject * obj4 = 0 ;
37036 PyObject * obj5 = 0 ;
37037 PyObject * obj6 = 0 ;
37038 PyObject * obj7 = 0 ;
37039 char *kwnames[] = {
37040 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37041 };
37042
37043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37045 if (SWIG_arg_fail(1)) SWIG_fail;
37046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37047 if (SWIG_arg_fail(2)) SWIG_fail;
37048 if (obj2) {
37049 {
37050 arg3 = (int)(SWIG_As_int(obj2));
37051 if (SWIG_arg_fail(3)) SWIG_fail;
37052 }
37053 }
37054 if (obj3) {
37055 {
37056 arg4 = &temp4;
37057 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37058 }
37059 }
37060 if (obj4) {
37061 {
37062 arg5 = &temp5;
37063 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37064 }
37065 }
37066 if (obj5) {
37067 {
37068 arg6 = (long)(SWIG_As_long(obj5));
37069 if (SWIG_arg_fail(6)) SWIG_fail;
37070 }
37071 }
37072 if (obj6) {
37073 {
37074 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37075 if (SWIG_arg_fail(7)) SWIG_fail;
37076 if (arg7 == NULL) {
37077 SWIG_null_ref("wxValidator");
37078 }
37079 if (SWIG_arg_fail(7)) SWIG_fail;
37080 }
37081 }
37082 if (obj7) {
37083 {
37084 arg8 = wxString_in_helper(obj7);
37085 if (arg8 == NULL) SWIG_fail;
37086 temp8 = true;
37087 }
37088 }
37089 {
37090 PyThreadState* __tstate = wxPyBeginAllowThreads();
37091 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37092
37093 wxPyEndAllowThreads(__tstate);
37094 if (PyErr_Occurred()) SWIG_fail;
37095 }
37096 {
37097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37098 }
37099 {
37100 if (temp8)
37101 delete arg8;
37102 }
37103 return resultobj;
37104 fail:
37105 {
37106 if (temp8)
37107 delete arg8;
37108 }
37109 return NULL;
37110 }
37111
37112
37113 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37114 PyObject *resultobj;
37115 wxControl *arg1 = (wxControl *) 0 ;
37116 wxCommandEvent *arg2 = 0 ;
37117 PyObject * obj0 = 0 ;
37118 PyObject * obj1 = 0 ;
37119 char *kwnames[] = {
37120 (char *) "self",(char *) "event", NULL
37121 };
37122
37123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37125 if (SWIG_arg_fail(1)) SWIG_fail;
37126 {
37127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37128 if (SWIG_arg_fail(2)) SWIG_fail;
37129 if (arg2 == NULL) {
37130 SWIG_null_ref("wxCommandEvent");
37131 }
37132 if (SWIG_arg_fail(2)) SWIG_fail;
37133 }
37134 {
37135 PyThreadState* __tstate = wxPyBeginAllowThreads();
37136 (arg1)->Command(*arg2);
37137
37138 wxPyEndAllowThreads(__tstate);
37139 if (PyErr_Occurred()) SWIG_fail;
37140 }
37141 Py_INCREF(Py_None); resultobj = Py_None;
37142 return resultobj;
37143 fail:
37144 return NULL;
37145 }
37146
37147
37148 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37149 PyObject *resultobj;
37150 wxControl *arg1 = (wxControl *) 0 ;
37151 wxString result;
37152 PyObject * obj0 = 0 ;
37153 char *kwnames[] = {
37154 (char *) "self", NULL
37155 };
37156
37157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37159 if (SWIG_arg_fail(1)) SWIG_fail;
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = (arg1)->GetLabel();
37163
37164 wxPyEndAllowThreads(__tstate);
37165 if (PyErr_Occurred()) SWIG_fail;
37166 }
37167 {
37168 #if wxUSE_UNICODE
37169 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37170 #else
37171 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37172 #endif
37173 }
37174 return resultobj;
37175 fail:
37176 return NULL;
37177 }
37178
37179
37180 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37181 PyObject *resultobj;
37182 wxControl *arg1 = (wxControl *) 0 ;
37183 wxString *arg2 = 0 ;
37184 bool temp2 = false ;
37185 PyObject * obj0 = 0 ;
37186 PyObject * obj1 = 0 ;
37187 char *kwnames[] = {
37188 (char *) "self",(char *) "label", NULL
37189 };
37190
37191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37193 if (SWIG_arg_fail(1)) SWIG_fail;
37194 {
37195 arg2 = wxString_in_helper(obj1);
37196 if (arg2 == NULL) SWIG_fail;
37197 temp2 = true;
37198 }
37199 {
37200 PyThreadState* __tstate = wxPyBeginAllowThreads();
37201 (arg1)->SetLabel((wxString const &)*arg2);
37202
37203 wxPyEndAllowThreads(__tstate);
37204 if (PyErr_Occurred()) SWIG_fail;
37205 }
37206 Py_INCREF(Py_None); resultobj = Py_None;
37207 {
37208 if (temp2)
37209 delete arg2;
37210 }
37211 return resultobj;
37212 fail:
37213 {
37214 if (temp2)
37215 delete arg2;
37216 }
37217 return NULL;
37218 }
37219
37220
37221 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37222 PyObject *resultobj;
37223 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37224 wxVisualAttributes result;
37225 PyObject * obj0 = 0 ;
37226 char *kwnames[] = {
37227 (char *) "variant", NULL
37228 };
37229
37230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37231 if (obj0) {
37232 {
37233 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37234 if (SWIG_arg_fail(1)) SWIG_fail;
37235 }
37236 }
37237 {
37238 if (!wxPyCheckForApp()) SWIG_fail;
37239 PyThreadState* __tstate = wxPyBeginAllowThreads();
37240 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37241
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 {
37246 wxVisualAttributes * resultptr;
37247 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37249 }
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37257 PyObject *obj;
37258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37259 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37260 Py_INCREF(obj);
37261 return Py_BuildValue((char *)"");
37262 }
37263 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37264 PyObject *resultobj;
37265 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37266 wxString *arg2 = 0 ;
37267 PyObject *arg3 = (PyObject *) NULL ;
37268 int result;
37269 bool temp2 = false ;
37270 PyObject * obj0 = 0 ;
37271 PyObject * obj1 = 0 ;
37272 PyObject * obj2 = 0 ;
37273 char *kwnames[] = {
37274 (char *) "self",(char *) "item",(char *) "clientData", NULL
37275 };
37276
37277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37279 if (SWIG_arg_fail(1)) SWIG_fail;
37280 {
37281 arg2 = wxString_in_helper(obj1);
37282 if (arg2 == NULL) SWIG_fail;
37283 temp2 = true;
37284 }
37285 if (obj2) {
37286 arg3 = obj2;
37287 }
37288 {
37289 PyThreadState* __tstate = wxPyBeginAllowThreads();
37290 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37291
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 {
37296 resultobj = SWIG_From_int((int)(result));
37297 }
37298 {
37299 if (temp2)
37300 delete arg2;
37301 }
37302 return resultobj;
37303 fail:
37304 {
37305 if (temp2)
37306 delete arg2;
37307 }
37308 return NULL;
37309 }
37310
37311
37312 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37313 PyObject *resultobj;
37314 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37315 wxArrayString *arg2 = 0 ;
37316 bool temp2 = false ;
37317 PyObject * obj0 = 0 ;
37318 PyObject * obj1 = 0 ;
37319 char *kwnames[] = {
37320 (char *) "self",(char *) "strings", NULL
37321 };
37322
37323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37325 if (SWIG_arg_fail(1)) SWIG_fail;
37326 {
37327 if (! PySequence_Check(obj1)) {
37328 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37329 SWIG_fail;
37330 }
37331 arg2 = new wxArrayString;
37332 temp2 = true;
37333 int i, len=PySequence_Length(obj1);
37334 for (i=0; i<len; i++) {
37335 PyObject* item = PySequence_GetItem(obj1, i);
37336 #if wxUSE_UNICODE
37337 PyObject* str = PyObject_Unicode(item);
37338 #else
37339 PyObject* str = PyObject_Str(item);
37340 #endif
37341 if (PyErr_Occurred()) SWIG_fail;
37342 arg2->Add(Py2wxString(str));
37343 Py_DECREF(item);
37344 Py_DECREF(str);
37345 }
37346 }
37347 {
37348 PyThreadState* __tstate = wxPyBeginAllowThreads();
37349 (arg1)->Append((wxArrayString const &)*arg2);
37350
37351 wxPyEndAllowThreads(__tstate);
37352 if (PyErr_Occurred()) SWIG_fail;
37353 }
37354 Py_INCREF(Py_None); resultobj = Py_None;
37355 {
37356 if (temp2) delete arg2;
37357 }
37358 return resultobj;
37359 fail:
37360 {
37361 if (temp2) delete arg2;
37362 }
37363 return NULL;
37364 }
37365
37366
37367 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37368 PyObject *resultobj;
37369 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37370 wxString *arg2 = 0 ;
37371 int arg3 ;
37372 PyObject *arg4 = (PyObject *) NULL ;
37373 int result;
37374 bool temp2 = false ;
37375 PyObject * obj0 = 0 ;
37376 PyObject * obj1 = 0 ;
37377 PyObject * obj2 = 0 ;
37378 PyObject * obj3 = 0 ;
37379 char *kwnames[] = {
37380 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37381 };
37382
37383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37385 if (SWIG_arg_fail(1)) SWIG_fail;
37386 {
37387 arg2 = wxString_in_helper(obj1);
37388 if (arg2 == NULL) SWIG_fail;
37389 temp2 = true;
37390 }
37391 {
37392 arg3 = (int)(SWIG_As_int(obj2));
37393 if (SWIG_arg_fail(3)) SWIG_fail;
37394 }
37395 if (obj3) {
37396 arg4 = obj3;
37397 }
37398 {
37399 PyThreadState* __tstate = wxPyBeginAllowThreads();
37400 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37401
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 {
37406 resultobj = SWIG_From_int((int)(result));
37407 }
37408 {
37409 if (temp2)
37410 delete arg2;
37411 }
37412 return resultobj;
37413 fail:
37414 {
37415 if (temp2)
37416 delete arg2;
37417 }
37418 return NULL;
37419 }
37420
37421
37422 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37423 PyObject *resultobj;
37424 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37425 PyObject * obj0 = 0 ;
37426 char *kwnames[] = {
37427 (char *) "self", NULL
37428 };
37429
37430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37432 if (SWIG_arg_fail(1)) SWIG_fail;
37433 {
37434 PyThreadState* __tstate = wxPyBeginAllowThreads();
37435 (arg1)->Clear();
37436
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 Py_INCREF(Py_None); resultobj = Py_None;
37441 return resultobj;
37442 fail:
37443 return NULL;
37444 }
37445
37446
37447 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37448 PyObject *resultobj;
37449 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37450 int arg2 ;
37451 PyObject * obj0 = 0 ;
37452 PyObject * obj1 = 0 ;
37453 char *kwnames[] = {
37454 (char *) "self",(char *) "n", NULL
37455 };
37456
37457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37459 if (SWIG_arg_fail(1)) SWIG_fail;
37460 {
37461 arg2 = (int)(SWIG_As_int(obj1));
37462 if (SWIG_arg_fail(2)) SWIG_fail;
37463 }
37464 {
37465 PyThreadState* __tstate = wxPyBeginAllowThreads();
37466 (arg1)->Delete(arg2);
37467
37468 wxPyEndAllowThreads(__tstate);
37469 if (PyErr_Occurred()) SWIG_fail;
37470 }
37471 Py_INCREF(Py_None); resultobj = Py_None;
37472 return resultobj;
37473 fail:
37474 return NULL;
37475 }
37476
37477
37478 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37479 PyObject *resultobj;
37480 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37481 int arg2 ;
37482 PyObject *result;
37483 PyObject * obj0 = 0 ;
37484 PyObject * obj1 = 0 ;
37485 char *kwnames[] = {
37486 (char *) "self",(char *) "n", NULL
37487 };
37488
37489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37491 if (SWIG_arg_fail(1)) SWIG_fail;
37492 {
37493 arg2 = (int)(SWIG_As_int(obj1));
37494 if (SWIG_arg_fail(2)) SWIG_fail;
37495 }
37496 {
37497 PyThreadState* __tstate = wxPyBeginAllowThreads();
37498 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37499
37500 wxPyEndAllowThreads(__tstate);
37501 if (PyErr_Occurred()) SWIG_fail;
37502 }
37503 resultobj = result;
37504 return resultobj;
37505 fail:
37506 return NULL;
37507 }
37508
37509
37510 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37511 PyObject *resultobj;
37512 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37513 int arg2 ;
37514 PyObject *arg3 = (PyObject *) 0 ;
37515 PyObject * obj0 = 0 ;
37516 PyObject * obj1 = 0 ;
37517 PyObject * obj2 = 0 ;
37518 char *kwnames[] = {
37519 (char *) "self",(char *) "n",(char *) "clientData", NULL
37520 };
37521
37522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37524 if (SWIG_arg_fail(1)) SWIG_fail;
37525 {
37526 arg2 = (int)(SWIG_As_int(obj1));
37527 if (SWIG_arg_fail(2)) SWIG_fail;
37528 }
37529 arg3 = obj2;
37530 {
37531 PyThreadState* __tstate = wxPyBeginAllowThreads();
37532 wxItemContainer_SetClientData(arg1,arg2,arg3);
37533
37534 wxPyEndAllowThreads(__tstate);
37535 if (PyErr_Occurred()) SWIG_fail;
37536 }
37537 Py_INCREF(Py_None); resultobj = Py_None;
37538 return resultobj;
37539 fail:
37540 return NULL;
37541 }
37542
37543
37544 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37545 PyObject *resultobj;
37546 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37547 int result;
37548 PyObject * obj0 = 0 ;
37549 char *kwnames[] = {
37550 (char *) "self", NULL
37551 };
37552
37553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37555 if (SWIG_arg_fail(1)) SWIG_fail;
37556 {
37557 PyThreadState* __tstate = wxPyBeginAllowThreads();
37558 result = (int)((wxItemContainer const *)arg1)->GetCount();
37559
37560 wxPyEndAllowThreads(__tstate);
37561 if (PyErr_Occurred()) SWIG_fail;
37562 }
37563 {
37564 resultobj = SWIG_From_int((int)(result));
37565 }
37566 return resultobj;
37567 fail:
37568 return NULL;
37569 }
37570
37571
37572 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37573 PyObject *resultobj;
37574 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37575 bool result;
37576 PyObject * obj0 = 0 ;
37577 char *kwnames[] = {
37578 (char *) "self", NULL
37579 };
37580
37581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37583 if (SWIG_arg_fail(1)) SWIG_fail;
37584 {
37585 PyThreadState* __tstate = wxPyBeginAllowThreads();
37586 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37587
37588 wxPyEndAllowThreads(__tstate);
37589 if (PyErr_Occurred()) SWIG_fail;
37590 }
37591 {
37592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37593 }
37594 return resultobj;
37595 fail:
37596 return NULL;
37597 }
37598
37599
37600 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37601 PyObject *resultobj;
37602 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37603 int arg2 ;
37604 wxString result;
37605 PyObject * obj0 = 0 ;
37606 PyObject * obj1 = 0 ;
37607 char *kwnames[] = {
37608 (char *) "self",(char *) "n", NULL
37609 };
37610
37611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37613 if (SWIG_arg_fail(1)) SWIG_fail;
37614 {
37615 arg2 = (int)(SWIG_As_int(obj1));
37616 if (SWIG_arg_fail(2)) SWIG_fail;
37617 }
37618 {
37619 PyThreadState* __tstate = wxPyBeginAllowThreads();
37620 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37621
37622 wxPyEndAllowThreads(__tstate);
37623 if (PyErr_Occurred()) SWIG_fail;
37624 }
37625 {
37626 #if wxUSE_UNICODE
37627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37628 #else
37629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37630 #endif
37631 }
37632 return resultobj;
37633 fail:
37634 return NULL;
37635 }
37636
37637
37638 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37639 PyObject *resultobj;
37640 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37641 wxArrayString result;
37642 PyObject * obj0 = 0 ;
37643 char *kwnames[] = {
37644 (char *) "self", NULL
37645 };
37646
37647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37649 if (SWIG_arg_fail(1)) SWIG_fail;
37650 {
37651 PyThreadState* __tstate = wxPyBeginAllowThreads();
37652 result = ((wxItemContainer const *)arg1)->GetStrings();
37653
37654 wxPyEndAllowThreads(__tstate);
37655 if (PyErr_Occurred()) SWIG_fail;
37656 }
37657 {
37658 resultobj = wxArrayString2PyList_helper(result);
37659 }
37660 return resultobj;
37661 fail:
37662 return NULL;
37663 }
37664
37665
37666 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37667 PyObject *resultobj;
37668 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37669 int arg2 ;
37670 wxString *arg3 = 0 ;
37671 bool temp3 = false ;
37672 PyObject * obj0 = 0 ;
37673 PyObject * obj1 = 0 ;
37674 PyObject * obj2 = 0 ;
37675 char *kwnames[] = {
37676 (char *) "self",(char *) "n",(char *) "s", NULL
37677 };
37678
37679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37681 if (SWIG_arg_fail(1)) SWIG_fail;
37682 {
37683 arg2 = (int)(SWIG_As_int(obj1));
37684 if (SWIG_arg_fail(2)) SWIG_fail;
37685 }
37686 {
37687 arg3 = wxString_in_helper(obj2);
37688 if (arg3 == NULL) SWIG_fail;
37689 temp3 = true;
37690 }
37691 {
37692 PyThreadState* __tstate = wxPyBeginAllowThreads();
37693 (arg1)->SetString(arg2,(wxString const &)*arg3);
37694
37695 wxPyEndAllowThreads(__tstate);
37696 if (PyErr_Occurred()) SWIG_fail;
37697 }
37698 Py_INCREF(Py_None); resultobj = Py_None;
37699 {
37700 if (temp3)
37701 delete arg3;
37702 }
37703 return resultobj;
37704 fail:
37705 {
37706 if (temp3)
37707 delete arg3;
37708 }
37709 return NULL;
37710 }
37711
37712
37713 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37714 PyObject *resultobj;
37715 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37716 wxString *arg2 = 0 ;
37717 int result;
37718 bool temp2 = false ;
37719 PyObject * obj0 = 0 ;
37720 PyObject * obj1 = 0 ;
37721 char *kwnames[] = {
37722 (char *) "self",(char *) "s", NULL
37723 };
37724
37725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37727 if (SWIG_arg_fail(1)) SWIG_fail;
37728 {
37729 arg2 = wxString_in_helper(obj1);
37730 if (arg2 == NULL) SWIG_fail;
37731 temp2 = true;
37732 }
37733 {
37734 PyThreadState* __tstate = wxPyBeginAllowThreads();
37735 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37736
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 {
37741 resultobj = SWIG_From_int((int)(result));
37742 }
37743 {
37744 if (temp2)
37745 delete arg2;
37746 }
37747 return resultobj;
37748 fail:
37749 {
37750 if (temp2)
37751 delete arg2;
37752 }
37753 return NULL;
37754 }
37755
37756
37757 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37758 PyObject *resultobj;
37759 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37760 int arg2 ;
37761 PyObject * obj0 = 0 ;
37762 PyObject * obj1 = 0 ;
37763 char *kwnames[] = {
37764 (char *) "self",(char *) "n", NULL
37765 };
37766
37767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37769 if (SWIG_arg_fail(1)) SWIG_fail;
37770 {
37771 arg2 = (int)(SWIG_As_int(obj1));
37772 if (SWIG_arg_fail(2)) SWIG_fail;
37773 }
37774 {
37775 PyThreadState* __tstate = wxPyBeginAllowThreads();
37776 (arg1)->SetSelection(arg2);
37777
37778 wxPyEndAllowThreads(__tstate);
37779 if (PyErr_Occurred()) SWIG_fail;
37780 }
37781 Py_INCREF(Py_None); resultobj = Py_None;
37782 return resultobj;
37783 fail:
37784 return NULL;
37785 }
37786
37787
37788 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37789 PyObject *resultobj;
37790 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37791 int result;
37792 PyObject * obj0 = 0 ;
37793 char *kwnames[] = {
37794 (char *) "self", NULL
37795 };
37796
37797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37799 if (SWIG_arg_fail(1)) SWIG_fail;
37800 {
37801 PyThreadState* __tstate = wxPyBeginAllowThreads();
37802 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37803
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 {
37808 resultobj = SWIG_From_int((int)(result));
37809 }
37810 return resultobj;
37811 fail:
37812 return NULL;
37813 }
37814
37815
37816 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37817 PyObject *resultobj;
37818 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37819 wxString *arg2 = 0 ;
37820 bool result;
37821 bool temp2 = false ;
37822 PyObject * obj0 = 0 ;
37823 PyObject * obj1 = 0 ;
37824 char *kwnames[] = {
37825 (char *) "self",(char *) "s", NULL
37826 };
37827
37828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37830 if (SWIG_arg_fail(1)) SWIG_fail;
37831 {
37832 arg2 = wxString_in_helper(obj1);
37833 if (arg2 == NULL) SWIG_fail;
37834 temp2 = true;
37835 }
37836 {
37837 PyThreadState* __tstate = wxPyBeginAllowThreads();
37838 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37839
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 {
37844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37845 }
37846 {
37847 if (temp2)
37848 delete arg2;
37849 }
37850 return resultobj;
37851 fail:
37852 {
37853 if (temp2)
37854 delete arg2;
37855 }
37856 return NULL;
37857 }
37858
37859
37860 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37861 PyObject *resultobj;
37862 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37863 wxString result;
37864 PyObject * obj0 = 0 ;
37865 char *kwnames[] = {
37866 (char *) "self", NULL
37867 };
37868
37869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37871 if (SWIG_arg_fail(1)) SWIG_fail;
37872 {
37873 PyThreadState* __tstate = wxPyBeginAllowThreads();
37874 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37875
37876 wxPyEndAllowThreads(__tstate);
37877 if (PyErr_Occurred()) SWIG_fail;
37878 }
37879 {
37880 #if wxUSE_UNICODE
37881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37882 #else
37883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37884 #endif
37885 }
37886 return resultobj;
37887 fail:
37888 return NULL;
37889 }
37890
37891
37892 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37893 PyObject *resultobj;
37894 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37895 int arg2 ;
37896 PyObject * obj0 = 0 ;
37897 PyObject * obj1 = 0 ;
37898 char *kwnames[] = {
37899 (char *) "self",(char *) "n", NULL
37900 };
37901
37902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37904 if (SWIG_arg_fail(1)) SWIG_fail;
37905 {
37906 arg2 = (int)(SWIG_As_int(obj1));
37907 if (SWIG_arg_fail(2)) SWIG_fail;
37908 }
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 (arg1)->Select(arg2);
37912
37913 wxPyEndAllowThreads(__tstate);
37914 if (PyErr_Occurred()) SWIG_fail;
37915 }
37916 Py_INCREF(Py_None); resultobj = Py_None;
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37924 PyObject *obj;
37925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37926 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37927 Py_INCREF(obj);
37928 return Py_BuildValue((char *)"");
37929 }
37930 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37931 PyObject *obj;
37932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37933 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37934 Py_INCREF(obj);
37935 return Py_BuildValue((char *)"");
37936 }
37937 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37938 PyObject *resultobj;
37939 wxSizerItem *result;
37940 char *kwnames[] = {
37941 NULL
37942 };
37943
37944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37945 {
37946 PyThreadState* __tstate = wxPyBeginAllowThreads();
37947 result = (wxSizerItem *)new wxSizerItem();
37948
37949 wxPyEndAllowThreads(__tstate);
37950 if (PyErr_Occurred()) SWIG_fail;
37951 }
37952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37953 return resultobj;
37954 fail:
37955 return NULL;
37956 }
37957
37958
37959 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37960 PyObject *resultobj;
37961 wxWindow *arg1 = (wxWindow *) 0 ;
37962 int arg2 ;
37963 int arg3 ;
37964 int arg4 ;
37965 PyObject *arg5 = (PyObject *) NULL ;
37966 wxSizerItem *result;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 PyObject * obj2 = 0 ;
37970 PyObject * obj3 = 0 ;
37971 PyObject * obj4 = 0 ;
37972 char *kwnames[] = {
37973 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37974 };
37975
37976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37978 if (SWIG_arg_fail(1)) SWIG_fail;
37979 {
37980 arg2 = (int)(SWIG_As_int(obj1));
37981 if (SWIG_arg_fail(2)) SWIG_fail;
37982 }
37983 {
37984 arg3 = (int)(SWIG_As_int(obj2));
37985 if (SWIG_arg_fail(3)) SWIG_fail;
37986 }
37987 {
37988 arg4 = (int)(SWIG_As_int(obj3));
37989 if (SWIG_arg_fail(4)) SWIG_fail;
37990 }
37991 if (obj4) {
37992 arg5 = obj4;
37993 }
37994 {
37995 PyThreadState* __tstate = wxPyBeginAllowThreads();
37996 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37997
37998 wxPyEndAllowThreads(__tstate);
37999 if (PyErr_Occurred()) SWIG_fail;
38000 }
38001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38002 return resultobj;
38003 fail:
38004 return NULL;
38005 }
38006
38007
38008 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj;
38010 int arg1 ;
38011 int arg2 ;
38012 int arg3 ;
38013 int arg4 ;
38014 int arg5 ;
38015 PyObject *arg6 = (PyObject *) NULL ;
38016 wxSizerItem *result;
38017 PyObject * obj0 = 0 ;
38018 PyObject * obj1 = 0 ;
38019 PyObject * obj2 = 0 ;
38020 PyObject * obj3 = 0 ;
38021 PyObject * obj4 = 0 ;
38022 PyObject * obj5 = 0 ;
38023 char *kwnames[] = {
38024 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38025 };
38026
38027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38028 {
38029 arg1 = (int)(SWIG_As_int(obj0));
38030 if (SWIG_arg_fail(1)) SWIG_fail;
38031 }
38032 {
38033 arg2 = (int)(SWIG_As_int(obj1));
38034 if (SWIG_arg_fail(2)) SWIG_fail;
38035 }
38036 {
38037 arg3 = (int)(SWIG_As_int(obj2));
38038 if (SWIG_arg_fail(3)) SWIG_fail;
38039 }
38040 {
38041 arg4 = (int)(SWIG_As_int(obj3));
38042 if (SWIG_arg_fail(4)) SWIG_fail;
38043 }
38044 {
38045 arg5 = (int)(SWIG_As_int(obj4));
38046 if (SWIG_arg_fail(5)) SWIG_fail;
38047 }
38048 if (obj5) {
38049 arg6 = obj5;
38050 }
38051 {
38052 PyThreadState* __tstate = wxPyBeginAllowThreads();
38053 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38054
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38059 return resultobj;
38060 fail:
38061 return NULL;
38062 }
38063
38064
38065 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38066 PyObject *resultobj;
38067 wxSizer *arg1 = (wxSizer *) 0 ;
38068 int arg2 ;
38069 int arg3 ;
38070 int arg4 ;
38071 PyObject *arg5 = (PyObject *) NULL ;
38072 wxSizerItem *result;
38073 PyObject * obj0 = 0 ;
38074 PyObject * obj1 = 0 ;
38075 PyObject * obj2 = 0 ;
38076 PyObject * obj3 = 0 ;
38077 PyObject * obj4 = 0 ;
38078 char *kwnames[] = {
38079 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38080 };
38081
38082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38084 if (SWIG_arg_fail(1)) SWIG_fail;
38085 {
38086 arg2 = (int)(SWIG_As_int(obj1));
38087 if (SWIG_arg_fail(2)) SWIG_fail;
38088 }
38089 {
38090 arg3 = (int)(SWIG_As_int(obj2));
38091 if (SWIG_arg_fail(3)) SWIG_fail;
38092 }
38093 {
38094 arg4 = (int)(SWIG_As_int(obj3));
38095 if (SWIG_arg_fail(4)) SWIG_fail;
38096 }
38097 if (obj4) {
38098 arg5 = obj4;
38099 }
38100 {
38101 PyThreadState* __tstate = wxPyBeginAllowThreads();
38102 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38103
38104 wxPyEndAllowThreads(__tstate);
38105 if (PyErr_Occurred()) SWIG_fail;
38106 }
38107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38115 PyObject *resultobj;
38116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38117 PyObject * obj0 = 0 ;
38118 char *kwnames[] = {
38119 (char *) "self", NULL
38120 };
38121
38122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38124 if (SWIG_arg_fail(1)) SWIG_fail;
38125 {
38126 PyThreadState* __tstate = wxPyBeginAllowThreads();
38127 (arg1)->DeleteWindows();
38128
38129 wxPyEndAllowThreads(__tstate);
38130 if (PyErr_Occurred()) SWIG_fail;
38131 }
38132 Py_INCREF(Py_None); resultobj = Py_None;
38133 return resultobj;
38134 fail:
38135 return NULL;
38136 }
38137
38138
38139 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38140 PyObject *resultobj;
38141 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38142 PyObject * obj0 = 0 ;
38143 char *kwnames[] = {
38144 (char *) "self", NULL
38145 };
38146
38147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38149 if (SWIG_arg_fail(1)) SWIG_fail;
38150 {
38151 PyThreadState* __tstate = wxPyBeginAllowThreads();
38152 (arg1)->DetachSizer();
38153
38154 wxPyEndAllowThreads(__tstate);
38155 if (PyErr_Occurred()) SWIG_fail;
38156 }
38157 Py_INCREF(Py_None); resultobj = Py_None;
38158 return resultobj;
38159 fail:
38160 return NULL;
38161 }
38162
38163
38164 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38165 PyObject *resultobj;
38166 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38167 wxSize result;
38168 PyObject * obj0 = 0 ;
38169 char *kwnames[] = {
38170 (char *) "self", NULL
38171 };
38172
38173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38175 if (SWIG_arg_fail(1)) SWIG_fail;
38176 {
38177 PyThreadState* __tstate = wxPyBeginAllowThreads();
38178 result = (arg1)->GetSize();
38179
38180 wxPyEndAllowThreads(__tstate);
38181 if (PyErr_Occurred()) SWIG_fail;
38182 }
38183 {
38184 wxSize * resultptr;
38185 resultptr = new wxSize((wxSize &)(result));
38186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38187 }
38188 return resultobj;
38189 fail:
38190 return NULL;
38191 }
38192
38193
38194 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj;
38196 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38197 wxSize result;
38198 PyObject * obj0 = 0 ;
38199 char *kwnames[] = {
38200 (char *) "self", NULL
38201 };
38202
38203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38205 if (SWIG_arg_fail(1)) SWIG_fail;
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 result = (arg1)->CalcMin();
38209
38210 wxPyEndAllowThreads(__tstate);
38211 if (PyErr_Occurred()) SWIG_fail;
38212 }
38213 {
38214 wxSize * resultptr;
38215 resultptr = new wxSize((wxSize &)(result));
38216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38217 }
38218 return resultobj;
38219 fail:
38220 return NULL;
38221 }
38222
38223
38224 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38225 PyObject *resultobj;
38226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38227 wxPoint arg2 ;
38228 wxSize arg3 ;
38229 PyObject * obj0 = 0 ;
38230 PyObject * obj1 = 0 ;
38231 PyObject * obj2 = 0 ;
38232 char *kwnames[] = {
38233 (char *) "self",(char *) "pos",(char *) "size", NULL
38234 };
38235
38236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38238 if (SWIG_arg_fail(1)) SWIG_fail;
38239 {
38240 wxPoint * argp;
38241 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38242 if (SWIG_arg_fail(2)) SWIG_fail;
38243 if (argp == NULL) {
38244 SWIG_null_ref("wxPoint");
38245 }
38246 if (SWIG_arg_fail(2)) SWIG_fail;
38247 arg2 = *argp;
38248 }
38249 {
38250 wxSize * argp;
38251 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38252 if (SWIG_arg_fail(3)) SWIG_fail;
38253 if (argp == NULL) {
38254 SWIG_null_ref("wxSize");
38255 }
38256 if (SWIG_arg_fail(3)) SWIG_fail;
38257 arg3 = *argp;
38258 }
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 (arg1)->SetDimension(arg2,arg3);
38262
38263 wxPyEndAllowThreads(__tstate);
38264 if (PyErr_Occurred()) SWIG_fail;
38265 }
38266 Py_INCREF(Py_None); resultobj = Py_None;
38267 return resultobj;
38268 fail:
38269 return NULL;
38270 }
38271
38272
38273 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38274 PyObject *resultobj;
38275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38276 wxSize result;
38277 PyObject * obj0 = 0 ;
38278 char *kwnames[] = {
38279 (char *) "self", NULL
38280 };
38281
38282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38284 if (SWIG_arg_fail(1)) SWIG_fail;
38285 {
38286 PyThreadState* __tstate = wxPyBeginAllowThreads();
38287 result = (arg1)->GetMinSize();
38288
38289 wxPyEndAllowThreads(__tstate);
38290 if (PyErr_Occurred()) SWIG_fail;
38291 }
38292 {
38293 wxSize * resultptr;
38294 resultptr = new wxSize((wxSize &)(result));
38295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38296 }
38297 return resultobj;
38298 fail:
38299 return NULL;
38300 }
38301
38302
38303 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38304 PyObject *resultobj;
38305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38306 wxSize result;
38307 PyObject * obj0 = 0 ;
38308 char *kwnames[] = {
38309 (char *) "self", NULL
38310 };
38311
38312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38314 if (SWIG_arg_fail(1)) SWIG_fail;
38315 {
38316 PyThreadState* __tstate = wxPyBeginAllowThreads();
38317 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38318
38319 wxPyEndAllowThreads(__tstate);
38320 if (PyErr_Occurred()) SWIG_fail;
38321 }
38322 {
38323 wxSize * resultptr;
38324 resultptr = new wxSize((wxSize &)(result));
38325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38326 }
38327 return resultobj;
38328 fail:
38329 return NULL;
38330 }
38331
38332
38333 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38334 PyObject *resultobj;
38335 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38336 int arg2 ;
38337 int arg3 ;
38338 PyObject * obj0 = 0 ;
38339 PyObject * obj1 = 0 ;
38340 PyObject * obj2 = 0 ;
38341 char *kwnames[] = {
38342 (char *) "self",(char *) "x",(char *) "y", NULL
38343 };
38344
38345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38347 if (SWIG_arg_fail(1)) SWIG_fail;
38348 {
38349 arg2 = (int)(SWIG_As_int(obj1));
38350 if (SWIG_arg_fail(2)) SWIG_fail;
38351 }
38352 {
38353 arg3 = (int)(SWIG_As_int(obj2));
38354 if (SWIG_arg_fail(3)) SWIG_fail;
38355 }
38356 {
38357 PyThreadState* __tstate = wxPyBeginAllowThreads();
38358 (arg1)->SetInitSize(arg2,arg3);
38359
38360 wxPyEndAllowThreads(__tstate);
38361 if (PyErr_Occurred()) SWIG_fail;
38362 }
38363 Py_INCREF(Py_None); resultobj = Py_None;
38364 return resultobj;
38365 fail:
38366 return NULL;
38367 }
38368
38369
38370 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38371 PyObject *resultobj;
38372 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38373 int arg2 ;
38374 int arg3 ;
38375 PyObject * obj0 = 0 ;
38376 PyObject * obj1 = 0 ;
38377 PyObject * obj2 = 0 ;
38378 char *kwnames[] = {
38379 (char *) "self",(char *) "width",(char *) "height", NULL
38380 };
38381
38382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38384 if (SWIG_arg_fail(1)) SWIG_fail;
38385 {
38386 arg2 = (int)(SWIG_As_int(obj1));
38387 if (SWIG_arg_fail(2)) SWIG_fail;
38388 }
38389 {
38390 arg3 = (int)(SWIG_As_int(obj2));
38391 if (SWIG_arg_fail(3)) SWIG_fail;
38392 }
38393 {
38394 PyThreadState* __tstate = wxPyBeginAllowThreads();
38395 (arg1)->SetRatio(arg2,arg3);
38396
38397 wxPyEndAllowThreads(__tstate);
38398 if (PyErr_Occurred()) SWIG_fail;
38399 }
38400 Py_INCREF(Py_None); resultobj = Py_None;
38401 return resultobj;
38402 fail:
38403 return NULL;
38404 }
38405
38406
38407 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38408 PyObject *resultobj;
38409 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38410 wxSize arg2 ;
38411 PyObject * obj0 = 0 ;
38412 PyObject * obj1 = 0 ;
38413 char *kwnames[] = {
38414 (char *) "self",(char *) "size", NULL
38415 };
38416
38417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38419 if (SWIG_arg_fail(1)) SWIG_fail;
38420 {
38421 wxSize * argp;
38422 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38423 if (SWIG_arg_fail(2)) SWIG_fail;
38424 if (argp == NULL) {
38425 SWIG_null_ref("wxSize");
38426 }
38427 if (SWIG_arg_fail(2)) SWIG_fail;
38428 arg2 = *argp;
38429 }
38430 {
38431 PyThreadState* __tstate = wxPyBeginAllowThreads();
38432 (arg1)->SetRatio(arg2);
38433
38434 wxPyEndAllowThreads(__tstate);
38435 if (PyErr_Occurred()) SWIG_fail;
38436 }
38437 Py_INCREF(Py_None); resultobj = Py_None;
38438 return resultobj;
38439 fail:
38440 return NULL;
38441 }
38442
38443
38444 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38445 PyObject *resultobj;
38446 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38447 float arg2 ;
38448 PyObject * obj0 = 0 ;
38449 PyObject * obj1 = 0 ;
38450 char *kwnames[] = {
38451 (char *) "self",(char *) "ratio", NULL
38452 };
38453
38454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38456 if (SWIG_arg_fail(1)) SWIG_fail;
38457 {
38458 arg2 = (float)(SWIG_As_float(obj1));
38459 if (SWIG_arg_fail(2)) SWIG_fail;
38460 }
38461 {
38462 PyThreadState* __tstate = wxPyBeginAllowThreads();
38463 (arg1)->SetRatio(arg2);
38464
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 Py_INCREF(Py_None); resultobj = Py_None;
38469 return resultobj;
38470 fail:
38471 return NULL;
38472 }
38473
38474
38475 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38476 PyObject *resultobj;
38477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38478 float result;
38479 PyObject * obj0 = 0 ;
38480 char *kwnames[] = {
38481 (char *) "self", NULL
38482 };
38483
38484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38486 if (SWIG_arg_fail(1)) SWIG_fail;
38487 {
38488 PyThreadState* __tstate = wxPyBeginAllowThreads();
38489 result = (float)(arg1)->GetRatio();
38490
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 {
38495 resultobj = SWIG_From_float((float)(result));
38496 }
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj;
38505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38506 wxRect result;
38507 PyObject * obj0 = 0 ;
38508 char *kwnames[] = {
38509 (char *) "self", NULL
38510 };
38511
38512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38514 if (SWIG_arg_fail(1)) SWIG_fail;
38515 {
38516 PyThreadState* __tstate = wxPyBeginAllowThreads();
38517 result = (arg1)->GetRect();
38518
38519 wxPyEndAllowThreads(__tstate);
38520 if (PyErr_Occurred()) SWIG_fail;
38521 }
38522 {
38523 wxRect * resultptr;
38524 resultptr = new wxRect((wxRect &)(result));
38525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38526 }
38527 return resultobj;
38528 fail:
38529 return NULL;
38530 }
38531
38532
38533 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38534 PyObject *resultobj;
38535 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38536 bool result;
38537 PyObject * obj0 = 0 ;
38538 char *kwnames[] = {
38539 (char *) "self", NULL
38540 };
38541
38542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38544 if (SWIG_arg_fail(1)) SWIG_fail;
38545 {
38546 PyThreadState* __tstate = wxPyBeginAllowThreads();
38547 result = (bool)(arg1)->IsWindow();
38548
38549 wxPyEndAllowThreads(__tstate);
38550 if (PyErr_Occurred()) SWIG_fail;
38551 }
38552 {
38553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38554 }
38555 return resultobj;
38556 fail:
38557 return NULL;
38558 }
38559
38560
38561 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38562 PyObject *resultobj;
38563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38564 bool result;
38565 PyObject * obj0 = 0 ;
38566 char *kwnames[] = {
38567 (char *) "self", NULL
38568 };
38569
38570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38572 if (SWIG_arg_fail(1)) SWIG_fail;
38573 {
38574 PyThreadState* __tstate = wxPyBeginAllowThreads();
38575 result = (bool)(arg1)->IsSizer();
38576
38577 wxPyEndAllowThreads(__tstate);
38578 if (PyErr_Occurred()) SWIG_fail;
38579 }
38580 {
38581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38582 }
38583 return resultobj;
38584 fail:
38585 return NULL;
38586 }
38587
38588
38589 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38590 PyObject *resultobj;
38591 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38592 bool result;
38593 PyObject * obj0 = 0 ;
38594 char *kwnames[] = {
38595 (char *) "self", NULL
38596 };
38597
38598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38600 if (SWIG_arg_fail(1)) SWIG_fail;
38601 {
38602 PyThreadState* __tstate = wxPyBeginAllowThreads();
38603 result = (bool)(arg1)->IsSpacer();
38604
38605 wxPyEndAllowThreads(__tstate);
38606 if (PyErr_Occurred()) SWIG_fail;
38607 }
38608 {
38609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38610 }
38611 return resultobj;
38612 fail:
38613 return NULL;
38614 }
38615
38616
38617 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38618 PyObject *resultobj;
38619 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38620 int arg2 ;
38621 PyObject * obj0 = 0 ;
38622 PyObject * obj1 = 0 ;
38623 char *kwnames[] = {
38624 (char *) "self",(char *) "proportion", NULL
38625 };
38626
38627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38629 if (SWIG_arg_fail(1)) SWIG_fail;
38630 {
38631 arg2 = (int)(SWIG_As_int(obj1));
38632 if (SWIG_arg_fail(2)) SWIG_fail;
38633 }
38634 {
38635 PyThreadState* __tstate = wxPyBeginAllowThreads();
38636 (arg1)->SetProportion(arg2);
38637
38638 wxPyEndAllowThreads(__tstate);
38639 if (PyErr_Occurred()) SWIG_fail;
38640 }
38641 Py_INCREF(Py_None); resultobj = Py_None;
38642 return resultobj;
38643 fail:
38644 return NULL;
38645 }
38646
38647
38648 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38649 PyObject *resultobj;
38650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38651 int result;
38652 PyObject * obj0 = 0 ;
38653 char *kwnames[] = {
38654 (char *) "self", NULL
38655 };
38656
38657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38659 if (SWIG_arg_fail(1)) SWIG_fail;
38660 {
38661 PyThreadState* __tstate = wxPyBeginAllowThreads();
38662 result = (int)(arg1)->GetProportion();
38663
38664 wxPyEndAllowThreads(__tstate);
38665 if (PyErr_Occurred()) SWIG_fail;
38666 }
38667 {
38668 resultobj = SWIG_From_int((int)(result));
38669 }
38670 return resultobj;
38671 fail:
38672 return NULL;
38673 }
38674
38675
38676 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38677 PyObject *resultobj;
38678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38679 int arg2 ;
38680 PyObject * obj0 = 0 ;
38681 PyObject * obj1 = 0 ;
38682 char *kwnames[] = {
38683 (char *) "self",(char *) "flag", NULL
38684 };
38685
38686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38688 if (SWIG_arg_fail(1)) SWIG_fail;
38689 {
38690 arg2 = (int)(SWIG_As_int(obj1));
38691 if (SWIG_arg_fail(2)) SWIG_fail;
38692 }
38693 {
38694 PyThreadState* __tstate = wxPyBeginAllowThreads();
38695 (arg1)->SetFlag(arg2);
38696
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 Py_INCREF(Py_None); resultobj = Py_None;
38701 return resultobj;
38702 fail:
38703 return NULL;
38704 }
38705
38706
38707 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38708 PyObject *resultobj;
38709 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38710 int result;
38711 PyObject * obj0 = 0 ;
38712 char *kwnames[] = {
38713 (char *) "self", NULL
38714 };
38715
38716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38718 if (SWIG_arg_fail(1)) SWIG_fail;
38719 {
38720 PyThreadState* __tstate = wxPyBeginAllowThreads();
38721 result = (int)(arg1)->GetFlag();
38722
38723 wxPyEndAllowThreads(__tstate);
38724 if (PyErr_Occurred()) SWIG_fail;
38725 }
38726 {
38727 resultobj = SWIG_From_int((int)(result));
38728 }
38729 return resultobj;
38730 fail:
38731 return NULL;
38732 }
38733
38734
38735 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38736 PyObject *resultobj;
38737 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38738 int arg2 ;
38739 PyObject * obj0 = 0 ;
38740 PyObject * obj1 = 0 ;
38741 char *kwnames[] = {
38742 (char *) "self",(char *) "border", NULL
38743 };
38744
38745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38747 if (SWIG_arg_fail(1)) SWIG_fail;
38748 {
38749 arg2 = (int)(SWIG_As_int(obj1));
38750 if (SWIG_arg_fail(2)) SWIG_fail;
38751 }
38752 {
38753 PyThreadState* __tstate = wxPyBeginAllowThreads();
38754 (arg1)->SetBorder(arg2);
38755
38756 wxPyEndAllowThreads(__tstate);
38757 if (PyErr_Occurred()) SWIG_fail;
38758 }
38759 Py_INCREF(Py_None); resultobj = Py_None;
38760 return resultobj;
38761 fail:
38762 return NULL;
38763 }
38764
38765
38766 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38767 PyObject *resultobj;
38768 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38769 int result;
38770 PyObject * obj0 = 0 ;
38771 char *kwnames[] = {
38772 (char *) "self", NULL
38773 };
38774
38775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38777 if (SWIG_arg_fail(1)) SWIG_fail;
38778 {
38779 PyThreadState* __tstate = wxPyBeginAllowThreads();
38780 result = (int)(arg1)->GetBorder();
38781
38782 wxPyEndAllowThreads(__tstate);
38783 if (PyErr_Occurred()) SWIG_fail;
38784 }
38785 {
38786 resultobj = SWIG_From_int((int)(result));
38787 }
38788 return resultobj;
38789 fail:
38790 return NULL;
38791 }
38792
38793
38794 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38795 PyObject *resultobj;
38796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38797 wxWindow *result;
38798 PyObject * obj0 = 0 ;
38799 char *kwnames[] = {
38800 (char *) "self", NULL
38801 };
38802
38803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38805 if (SWIG_arg_fail(1)) SWIG_fail;
38806 {
38807 PyThreadState* __tstate = wxPyBeginAllowThreads();
38808 result = (wxWindow *)(arg1)->GetWindow();
38809
38810 wxPyEndAllowThreads(__tstate);
38811 if (PyErr_Occurred()) SWIG_fail;
38812 }
38813 {
38814 resultobj = wxPyMake_wxObject(result, 0);
38815 }
38816 return resultobj;
38817 fail:
38818 return NULL;
38819 }
38820
38821
38822 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38823 PyObject *resultobj;
38824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38825 wxWindow *arg2 = (wxWindow *) 0 ;
38826 PyObject * obj0 = 0 ;
38827 PyObject * obj1 = 0 ;
38828 char *kwnames[] = {
38829 (char *) "self",(char *) "window", NULL
38830 };
38831
38832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38834 if (SWIG_arg_fail(1)) SWIG_fail;
38835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38836 if (SWIG_arg_fail(2)) SWIG_fail;
38837 {
38838 PyThreadState* __tstate = wxPyBeginAllowThreads();
38839 (arg1)->SetWindow(arg2);
38840
38841 wxPyEndAllowThreads(__tstate);
38842 if (PyErr_Occurred()) SWIG_fail;
38843 }
38844 Py_INCREF(Py_None); resultobj = Py_None;
38845 return resultobj;
38846 fail:
38847 return NULL;
38848 }
38849
38850
38851 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38852 PyObject *resultobj;
38853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38854 wxSizer *result;
38855 PyObject * obj0 = 0 ;
38856 char *kwnames[] = {
38857 (char *) "self", NULL
38858 };
38859
38860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38862 if (SWIG_arg_fail(1)) SWIG_fail;
38863 {
38864 PyThreadState* __tstate = wxPyBeginAllowThreads();
38865 result = (wxSizer *)(arg1)->GetSizer();
38866
38867 wxPyEndAllowThreads(__tstate);
38868 if (PyErr_Occurred()) SWIG_fail;
38869 }
38870 {
38871 resultobj = wxPyMake_wxSizer(result, 0);
38872 }
38873 return resultobj;
38874 fail:
38875 return NULL;
38876 }
38877
38878
38879 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38880 PyObject *resultobj;
38881 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38882 wxSizer *arg2 = (wxSizer *) 0 ;
38883 PyObject * obj0 = 0 ;
38884 PyObject * obj1 = 0 ;
38885 char *kwnames[] = {
38886 (char *) "self",(char *) "sizer", NULL
38887 };
38888
38889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38891 if (SWIG_arg_fail(1)) SWIG_fail;
38892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38893 if (SWIG_arg_fail(2)) SWIG_fail;
38894 {
38895 PyThreadState* __tstate = wxPyBeginAllowThreads();
38896 (arg1)->SetSizer(arg2);
38897
38898 wxPyEndAllowThreads(__tstate);
38899 if (PyErr_Occurred()) SWIG_fail;
38900 }
38901 Py_INCREF(Py_None); resultobj = Py_None;
38902 return resultobj;
38903 fail:
38904 return NULL;
38905 }
38906
38907
38908 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38909 PyObject *resultobj;
38910 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38911 wxSize *result;
38912 PyObject * obj0 = 0 ;
38913 char *kwnames[] = {
38914 (char *) "self", NULL
38915 };
38916
38917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38919 if (SWIG_arg_fail(1)) SWIG_fail;
38920 {
38921 PyThreadState* __tstate = wxPyBeginAllowThreads();
38922 {
38923 wxSize const &_result_ref = (arg1)->GetSpacer();
38924 result = (wxSize *) &_result_ref;
38925 }
38926
38927 wxPyEndAllowThreads(__tstate);
38928 if (PyErr_Occurred()) SWIG_fail;
38929 }
38930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38931 return resultobj;
38932 fail:
38933 return NULL;
38934 }
38935
38936
38937 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38938 PyObject *resultobj;
38939 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38940 wxSize *arg2 = 0 ;
38941 wxSize temp2 ;
38942 PyObject * obj0 = 0 ;
38943 PyObject * obj1 = 0 ;
38944 char *kwnames[] = {
38945 (char *) "self",(char *) "size", NULL
38946 };
38947
38948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38950 if (SWIG_arg_fail(1)) SWIG_fail;
38951 {
38952 arg2 = &temp2;
38953 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38954 }
38955 {
38956 PyThreadState* __tstate = wxPyBeginAllowThreads();
38957 (arg1)->SetSpacer((wxSize const &)*arg2);
38958
38959 wxPyEndAllowThreads(__tstate);
38960 if (PyErr_Occurred()) SWIG_fail;
38961 }
38962 Py_INCREF(Py_None); resultobj = Py_None;
38963 return resultobj;
38964 fail:
38965 return NULL;
38966 }
38967
38968
38969 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38970 PyObject *resultobj;
38971 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38972 bool arg2 ;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 char *kwnames[] = {
38976 (char *) "self",(char *) "show", NULL
38977 };
38978
38979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",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 = (bool)(SWIG_As_bool(obj1));
38984 if (SWIG_arg_fail(2)) SWIG_fail;
38985 }
38986 {
38987 PyThreadState* __tstate = wxPyBeginAllowThreads();
38988 (arg1)->Show(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_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39001 PyObject *resultobj;
39002 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39003 bool result;
39004 PyObject * obj0 = 0 ;
39005 char *kwnames[] = {
39006 (char *) "self", NULL
39007 };
39008
39009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39011 if (SWIG_arg_fail(1)) SWIG_fail;
39012 {
39013 PyThreadState* __tstate = wxPyBeginAllowThreads();
39014 result = (bool)(arg1)->IsShown();
39015
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 {
39020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39021 }
39022 return resultobj;
39023 fail:
39024 return NULL;
39025 }
39026
39027
39028 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39029 PyObject *resultobj;
39030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39031 wxPoint result;
39032 PyObject * obj0 = 0 ;
39033 char *kwnames[] = {
39034 (char *) "self", NULL
39035 };
39036
39037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39039 if (SWIG_arg_fail(1)) SWIG_fail;
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 result = (arg1)->GetPosition();
39043
39044 wxPyEndAllowThreads(__tstate);
39045 if (PyErr_Occurred()) SWIG_fail;
39046 }
39047 {
39048 wxPoint * resultptr;
39049 resultptr = new wxPoint((wxPoint &)(result));
39050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39051 }
39052 return resultobj;
39053 fail:
39054 return NULL;
39055 }
39056
39057
39058 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39059 PyObject *resultobj;
39060 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39061 PyObject *result;
39062 PyObject * obj0 = 0 ;
39063 char *kwnames[] = {
39064 (char *) "self", NULL
39065 };
39066
39067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39069 if (SWIG_arg_fail(1)) SWIG_fail;
39070 {
39071 PyThreadState* __tstate = wxPyBeginAllowThreads();
39072 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39073
39074 wxPyEndAllowThreads(__tstate);
39075 if (PyErr_Occurred()) SWIG_fail;
39076 }
39077 resultobj = result;
39078 return resultobj;
39079 fail:
39080 return NULL;
39081 }
39082
39083
39084 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39085 PyObject *obj;
39086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39087 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39088 Py_INCREF(obj);
39089 return Py_BuildValue((char *)"");
39090 }
39091 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39092 PyObject *resultobj;
39093 wxSizer *arg1 = (wxSizer *) 0 ;
39094 PyObject *arg2 = (PyObject *) 0 ;
39095 PyObject * obj0 = 0 ;
39096 PyObject * obj1 = 0 ;
39097 char *kwnames[] = {
39098 (char *) "self",(char *) "_self", NULL
39099 };
39100
39101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39103 if (SWIG_arg_fail(1)) SWIG_fail;
39104 arg2 = obj1;
39105 {
39106 PyThreadState* __tstate = wxPyBeginAllowThreads();
39107 wxSizer__setOORInfo(arg1,arg2);
39108
39109 wxPyEndAllowThreads(__tstate);
39110 if (PyErr_Occurred()) SWIG_fail;
39111 }
39112 Py_INCREF(Py_None); resultobj = Py_None;
39113 return resultobj;
39114 fail:
39115 return NULL;
39116 }
39117
39118
39119 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39120 PyObject *resultobj;
39121 wxSizer *arg1 = (wxSizer *) 0 ;
39122 PyObject *arg2 = (PyObject *) 0 ;
39123 int arg3 = (int) 0 ;
39124 int arg4 = (int) 0 ;
39125 int arg5 = (int) 0 ;
39126 PyObject *arg6 = (PyObject *) NULL ;
39127 wxSizerItem *result;
39128 PyObject * obj0 = 0 ;
39129 PyObject * obj1 = 0 ;
39130 PyObject * obj2 = 0 ;
39131 PyObject * obj3 = 0 ;
39132 PyObject * obj4 = 0 ;
39133 PyObject * obj5 = 0 ;
39134 char *kwnames[] = {
39135 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39136 };
39137
39138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39140 if (SWIG_arg_fail(1)) SWIG_fail;
39141 arg2 = obj1;
39142 if (obj2) {
39143 {
39144 arg3 = (int)(SWIG_As_int(obj2));
39145 if (SWIG_arg_fail(3)) SWIG_fail;
39146 }
39147 }
39148 if (obj3) {
39149 {
39150 arg4 = (int)(SWIG_As_int(obj3));
39151 if (SWIG_arg_fail(4)) SWIG_fail;
39152 }
39153 }
39154 if (obj4) {
39155 {
39156 arg5 = (int)(SWIG_As_int(obj4));
39157 if (SWIG_arg_fail(5)) SWIG_fail;
39158 }
39159 }
39160 if (obj5) {
39161 arg6 = obj5;
39162 }
39163 {
39164 PyThreadState* __tstate = wxPyBeginAllowThreads();
39165 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39166
39167 wxPyEndAllowThreads(__tstate);
39168 if (PyErr_Occurred()) SWIG_fail;
39169 }
39170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39171 return resultobj;
39172 fail:
39173 return NULL;
39174 }
39175
39176
39177 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39178 PyObject *resultobj;
39179 wxSizer *arg1 = (wxSizer *) 0 ;
39180 int arg2 ;
39181 PyObject *arg3 = (PyObject *) 0 ;
39182 int arg4 = (int) 0 ;
39183 int arg5 = (int) 0 ;
39184 int arg6 = (int) 0 ;
39185 PyObject *arg7 = (PyObject *) NULL ;
39186 wxSizerItem *result;
39187 PyObject * obj0 = 0 ;
39188 PyObject * obj1 = 0 ;
39189 PyObject * obj2 = 0 ;
39190 PyObject * obj3 = 0 ;
39191 PyObject * obj4 = 0 ;
39192 PyObject * obj5 = 0 ;
39193 PyObject * obj6 = 0 ;
39194 char *kwnames[] = {
39195 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39196 };
39197
39198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39200 if (SWIG_arg_fail(1)) SWIG_fail;
39201 {
39202 arg2 = (int)(SWIG_As_int(obj1));
39203 if (SWIG_arg_fail(2)) SWIG_fail;
39204 }
39205 arg3 = obj2;
39206 if (obj3) {
39207 {
39208 arg4 = (int)(SWIG_As_int(obj3));
39209 if (SWIG_arg_fail(4)) SWIG_fail;
39210 }
39211 }
39212 if (obj4) {
39213 {
39214 arg5 = (int)(SWIG_As_int(obj4));
39215 if (SWIG_arg_fail(5)) SWIG_fail;
39216 }
39217 }
39218 if (obj5) {
39219 {
39220 arg6 = (int)(SWIG_As_int(obj5));
39221 if (SWIG_arg_fail(6)) SWIG_fail;
39222 }
39223 }
39224 if (obj6) {
39225 arg7 = obj6;
39226 }
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39230
39231 wxPyEndAllowThreads(__tstate);
39232 if (PyErr_Occurred()) SWIG_fail;
39233 }
39234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39235 return resultobj;
39236 fail:
39237 return NULL;
39238 }
39239
39240
39241 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39242 PyObject *resultobj;
39243 wxSizer *arg1 = (wxSizer *) 0 ;
39244 PyObject *arg2 = (PyObject *) 0 ;
39245 int arg3 = (int) 0 ;
39246 int arg4 = (int) 0 ;
39247 int arg5 = (int) 0 ;
39248 PyObject *arg6 = (PyObject *) NULL ;
39249 wxSizerItem *result;
39250 PyObject * obj0 = 0 ;
39251 PyObject * obj1 = 0 ;
39252 PyObject * obj2 = 0 ;
39253 PyObject * obj3 = 0 ;
39254 PyObject * obj4 = 0 ;
39255 PyObject * obj5 = 0 ;
39256 char *kwnames[] = {
39257 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39258 };
39259
39260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39262 if (SWIG_arg_fail(1)) SWIG_fail;
39263 arg2 = obj1;
39264 if (obj2) {
39265 {
39266 arg3 = (int)(SWIG_As_int(obj2));
39267 if (SWIG_arg_fail(3)) SWIG_fail;
39268 }
39269 }
39270 if (obj3) {
39271 {
39272 arg4 = (int)(SWIG_As_int(obj3));
39273 if (SWIG_arg_fail(4)) SWIG_fail;
39274 }
39275 }
39276 if (obj4) {
39277 {
39278 arg5 = (int)(SWIG_As_int(obj4));
39279 if (SWIG_arg_fail(5)) SWIG_fail;
39280 }
39281 }
39282 if (obj5) {
39283 arg6 = obj5;
39284 }
39285 {
39286 PyThreadState* __tstate = wxPyBeginAllowThreads();
39287 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39288
39289 wxPyEndAllowThreads(__tstate);
39290 if (PyErr_Occurred()) SWIG_fail;
39291 }
39292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39293 return resultobj;
39294 fail:
39295 return NULL;
39296 }
39297
39298
39299 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39300 PyObject *resultobj;
39301 wxSizer *arg1 = (wxSizer *) 0 ;
39302 PyObject *arg2 = (PyObject *) 0 ;
39303 bool result;
39304 PyObject * obj0 = 0 ;
39305 PyObject * obj1 = 0 ;
39306 char *kwnames[] = {
39307 (char *) "self",(char *) "item", NULL
39308 };
39309
39310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39312 if (SWIG_arg_fail(1)) SWIG_fail;
39313 arg2 = obj1;
39314 {
39315 PyThreadState* __tstate = wxPyBeginAllowThreads();
39316 result = (bool)wxSizer_Remove(arg1,arg2);
39317
39318 wxPyEndAllowThreads(__tstate);
39319 if (PyErr_Occurred()) SWIG_fail;
39320 }
39321 {
39322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39323 }
39324 return resultobj;
39325 fail:
39326 return NULL;
39327 }
39328
39329
39330 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39331 PyObject *resultobj;
39332 wxSizer *arg1 = (wxSizer *) 0 ;
39333 PyObject *arg2 = (PyObject *) 0 ;
39334 bool result;
39335 PyObject * obj0 = 0 ;
39336 PyObject * obj1 = 0 ;
39337 char *kwnames[] = {
39338 (char *) "self",(char *) "item", NULL
39339 };
39340
39341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39343 if (SWIG_arg_fail(1)) SWIG_fail;
39344 arg2 = obj1;
39345 {
39346 PyThreadState* __tstate = wxPyBeginAllowThreads();
39347 result = (bool)wxSizer_Detach(arg1,arg2);
39348
39349 wxPyEndAllowThreads(__tstate);
39350 if (PyErr_Occurred()) SWIG_fail;
39351 }
39352 {
39353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39354 }
39355 return resultobj;
39356 fail:
39357 return NULL;
39358 }
39359
39360
39361 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39362 PyObject *resultobj;
39363 wxSizer *arg1 = (wxSizer *) 0 ;
39364 PyObject *arg2 = (PyObject *) 0 ;
39365 wxSizerItem *result;
39366 PyObject * obj0 = 0 ;
39367 PyObject * obj1 = 0 ;
39368 char *kwnames[] = {
39369 (char *) "self",(char *) "item", NULL
39370 };
39371
39372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39374 if (SWIG_arg_fail(1)) SWIG_fail;
39375 arg2 = obj1;
39376 {
39377 PyThreadState* __tstate = wxPyBeginAllowThreads();
39378 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39379
39380 wxPyEndAllowThreads(__tstate);
39381 if (PyErr_Occurred()) SWIG_fail;
39382 }
39383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39384 return resultobj;
39385 fail:
39386 return NULL;
39387 }
39388
39389
39390 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39391 PyObject *resultobj;
39392 wxSizer *arg1 = (wxSizer *) 0 ;
39393 PyObject *arg2 = (PyObject *) 0 ;
39394 wxSize *arg3 = 0 ;
39395 wxSize temp3 ;
39396 PyObject * obj0 = 0 ;
39397 PyObject * obj1 = 0 ;
39398 PyObject * obj2 = 0 ;
39399 char *kwnames[] = {
39400 (char *) "self",(char *) "item",(char *) "size", NULL
39401 };
39402
39403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39405 if (SWIG_arg_fail(1)) SWIG_fail;
39406 arg2 = obj1;
39407 {
39408 arg3 = &temp3;
39409 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39410 }
39411 {
39412 PyThreadState* __tstate = wxPyBeginAllowThreads();
39413 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39414
39415 wxPyEndAllowThreads(__tstate);
39416 if (PyErr_Occurred()) SWIG_fail;
39417 }
39418 Py_INCREF(Py_None); resultobj = Py_None;
39419 return resultobj;
39420 fail:
39421 return NULL;
39422 }
39423
39424
39425 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39426 PyObject *resultobj;
39427 wxSizer *arg1 = (wxSizer *) 0 ;
39428 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39429 wxSizerItem *result;
39430 PyObject * obj0 = 0 ;
39431 PyObject * obj1 = 0 ;
39432 char *kwnames[] = {
39433 (char *) "self",(char *) "item", NULL
39434 };
39435
39436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39438 if (SWIG_arg_fail(1)) SWIG_fail;
39439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39440 if (SWIG_arg_fail(2)) SWIG_fail;
39441 {
39442 PyThreadState* __tstate = wxPyBeginAllowThreads();
39443 result = (wxSizerItem *)(arg1)->Add(arg2);
39444
39445 wxPyEndAllowThreads(__tstate);
39446 if (PyErr_Occurred()) SWIG_fail;
39447 }
39448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39449 return resultobj;
39450 fail:
39451 return NULL;
39452 }
39453
39454
39455 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39456 PyObject *resultobj;
39457 wxSizer *arg1 = (wxSizer *) 0 ;
39458 size_t arg2 ;
39459 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39460 wxSizerItem *result;
39461 PyObject * obj0 = 0 ;
39462 PyObject * obj1 = 0 ;
39463 PyObject * obj2 = 0 ;
39464 char *kwnames[] = {
39465 (char *) "self",(char *) "index",(char *) "item", NULL
39466 };
39467
39468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39470 if (SWIG_arg_fail(1)) SWIG_fail;
39471 {
39472 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39473 if (SWIG_arg_fail(2)) SWIG_fail;
39474 }
39475 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39476 if (SWIG_arg_fail(3)) SWIG_fail;
39477 {
39478 PyThreadState* __tstate = wxPyBeginAllowThreads();
39479 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39480
39481 wxPyEndAllowThreads(__tstate);
39482 if (PyErr_Occurred()) SWIG_fail;
39483 }
39484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39485 return resultobj;
39486 fail:
39487 return NULL;
39488 }
39489
39490
39491 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39492 PyObject *resultobj;
39493 wxSizer *arg1 = (wxSizer *) 0 ;
39494 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39495 wxSizerItem *result;
39496 PyObject * obj0 = 0 ;
39497 PyObject * obj1 = 0 ;
39498 char *kwnames[] = {
39499 (char *) "self",(char *) "item", NULL
39500 };
39501
39502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39504 if (SWIG_arg_fail(1)) SWIG_fail;
39505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39506 if (SWIG_arg_fail(2)) SWIG_fail;
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39510
39511 wxPyEndAllowThreads(__tstate);
39512 if (PyErr_Occurred()) SWIG_fail;
39513 }
39514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39515 return resultobj;
39516 fail:
39517 return NULL;
39518 }
39519
39520
39521 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39522 PyObject *resultobj;
39523 wxSizer *arg1 = (wxSizer *) 0 ;
39524 int arg2 ;
39525 int arg3 ;
39526 int arg4 ;
39527 int arg5 ;
39528 PyObject * obj0 = 0 ;
39529 PyObject * obj1 = 0 ;
39530 PyObject * obj2 = 0 ;
39531 PyObject * obj3 = 0 ;
39532 PyObject * obj4 = 0 ;
39533 char *kwnames[] = {
39534 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39535 };
39536
39537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39539 if (SWIG_arg_fail(1)) SWIG_fail;
39540 {
39541 arg2 = (int)(SWIG_As_int(obj1));
39542 if (SWIG_arg_fail(2)) SWIG_fail;
39543 }
39544 {
39545 arg3 = (int)(SWIG_As_int(obj2));
39546 if (SWIG_arg_fail(3)) SWIG_fail;
39547 }
39548 {
39549 arg4 = (int)(SWIG_As_int(obj3));
39550 if (SWIG_arg_fail(4)) SWIG_fail;
39551 }
39552 {
39553 arg5 = (int)(SWIG_As_int(obj4));
39554 if (SWIG_arg_fail(5)) SWIG_fail;
39555 }
39556 {
39557 PyThreadState* __tstate = wxPyBeginAllowThreads();
39558 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39559
39560 wxPyEndAllowThreads(__tstate);
39561 if (PyErr_Occurred()) SWIG_fail;
39562 }
39563 Py_INCREF(Py_None); resultobj = Py_None;
39564 return resultobj;
39565 fail:
39566 return NULL;
39567 }
39568
39569
39570 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39571 PyObject *resultobj;
39572 wxSizer *arg1 = (wxSizer *) 0 ;
39573 wxSize *arg2 = 0 ;
39574 wxSize temp2 ;
39575 PyObject * obj0 = 0 ;
39576 PyObject * obj1 = 0 ;
39577 char *kwnames[] = {
39578 (char *) "self",(char *) "size", NULL
39579 };
39580
39581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39583 if (SWIG_arg_fail(1)) SWIG_fail;
39584 {
39585 arg2 = &temp2;
39586 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39587 }
39588 {
39589 PyThreadState* __tstate = wxPyBeginAllowThreads();
39590 (arg1)->SetMinSize((wxSize const &)*arg2);
39591
39592 wxPyEndAllowThreads(__tstate);
39593 if (PyErr_Occurred()) SWIG_fail;
39594 }
39595 Py_INCREF(Py_None); resultobj = Py_None;
39596 return resultobj;
39597 fail:
39598 return NULL;
39599 }
39600
39601
39602 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39603 PyObject *resultobj;
39604 wxSizer *arg1 = (wxSizer *) 0 ;
39605 wxSize result;
39606 PyObject * obj0 = 0 ;
39607 char *kwnames[] = {
39608 (char *) "self", NULL
39609 };
39610
39611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39613 if (SWIG_arg_fail(1)) SWIG_fail;
39614 {
39615 PyThreadState* __tstate = wxPyBeginAllowThreads();
39616 result = (arg1)->GetSize();
39617
39618 wxPyEndAllowThreads(__tstate);
39619 if (PyErr_Occurred()) SWIG_fail;
39620 }
39621 {
39622 wxSize * resultptr;
39623 resultptr = new wxSize((wxSize &)(result));
39624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39625 }
39626 return resultobj;
39627 fail:
39628 return NULL;
39629 }
39630
39631
39632 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39633 PyObject *resultobj;
39634 wxSizer *arg1 = (wxSizer *) 0 ;
39635 wxPoint result;
39636 PyObject * obj0 = 0 ;
39637 char *kwnames[] = {
39638 (char *) "self", NULL
39639 };
39640
39641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39643 if (SWIG_arg_fail(1)) SWIG_fail;
39644 {
39645 PyThreadState* __tstate = wxPyBeginAllowThreads();
39646 result = (arg1)->GetPosition();
39647
39648 wxPyEndAllowThreads(__tstate);
39649 if (PyErr_Occurred()) SWIG_fail;
39650 }
39651 {
39652 wxPoint * resultptr;
39653 resultptr = new wxPoint((wxPoint &)(result));
39654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39655 }
39656 return resultobj;
39657 fail:
39658 return NULL;
39659 }
39660
39661
39662 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39663 PyObject *resultobj;
39664 wxSizer *arg1 = (wxSizer *) 0 ;
39665 wxSize result;
39666 PyObject * obj0 = 0 ;
39667 char *kwnames[] = {
39668 (char *) "self", NULL
39669 };
39670
39671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39673 if (SWIG_arg_fail(1)) SWIG_fail;
39674 {
39675 PyThreadState* __tstate = wxPyBeginAllowThreads();
39676 result = (arg1)->GetMinSize();
39677
39678 wxPyEndAllowThreads(__tstate);
39679 if (PyErr_Occurred()) SWIG_fail;
39680 }
39681 {
39682 wxSize * resultptr;
39683 resultptr = new wxSize((wxSize &)(result));
39684 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39685 }
39686 return resultobj;
39687 fail:
39688 return NULL;
39689 }
39690
39691
39692 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39693 PyObject *resultobj;
39694 wxSizer *arg1 = (wxSizer *) 0 ;
39695 PyObject * obj0 = 0 ;
39696 char *kwnames[] = {
39697 (char *) "self", NULL
39698 };
39699
39700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39702 if (SWIG_arg_fail(1)) SWIG_fail;
39703 {
39704 PyThreadState* __tstate = wxPyBeginAllowThreads();
39705 (arg1)->RecalcSizes();
39706
39707 wxPyEndAllowThreads(__tstate);
39708 if (PyErr_Occurred()) SWIG_fail;
39709 }
39710 Py_INCREF(Py_None); resultobj = Py_None;
39711 return resultobj;
39712 fail:
39713 return NULL;
39714 }
39715
39716
39717 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39718 PyObject *resultobj;
39719 wxSizer *arg1 = (wxSizer *) 0 ;
39720 wxSize result;
39721 PyObject * obj0 = 0 ;
39722 char *kwnames[] = {
39723 (char *) "self", NULL
39724 };
39725
39726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39728 if (SWIG_arg_fail(1)) SWIG_fail;
39729 {
39730 PyThreadState* __tstate = wxPyBeginAllowThreads();
39731 result = (arg1)->CalcMin();
39732
39733 wxPyEndAllowThreads(__tstate);
39734 if (PyErr_Occurred()) SWIG_fail;
39735 }
39736 {
39737 wxSize * resultptr;
39738 resultptr = new wxSize((wxSize &)(result));
39739 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39740 }
39741 return resultobj;
39742 fail:
39743 return NULL;
39744 }
39745
39746
39747 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39748 PyObject *resultobj;
39749 wxSizer *arg1 = (wxSizer *) 0 ;
39750 PyObject * obj0 = 0 ;
39751 char *kwnames[] = {
39752 (char *) "self", NULL
39753 };
39754
39755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39757 if (SWIG_arg_fail(1)) SWIG_fail;
39758 {
39759 PyThreadState* __tstate = wxPyBeginAllowThreads();
39760 (arg1)->Layout();
39761
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 Py_INCREF(Py_None); resultobj = Py_None;
39766 return resultobj;
39767 fail:
39768 return NULL;
39769 }
39770
39771
39772 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39773 PyObject *resultobj;
39774 wxSizer *arg1 = (wxSizer *) 0 ;
39775 wxWindow *arg2 = (wxWindow *) 0 ;
39776 wxSize result;
39777 PyObject * obj0 = 0 ;
39778 PyObject * obj1 = 0 ;
39779 char *kwnames[] = {
39780 (char *) "self",(char *) "window", NULL
39781 };
39782
39783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39785 if (SWIG_arg_fail(1)) SWIG_fail;
39786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39787 if (SWIG_arg_fail(2)) SWIG_fail;
39788 {
39789 PyThreadState* __tstate = wxPyBeginAllowThreads();
39790 result = (arg1)->Fit(arg2);
39791
39792 wxPyEndAllowThreads(__tstate);
39793 if (PyErr_Occurred()) SWIG_fail;
39794 }
39795 {
39796 wxSize * resultptr;
39797 resultptr = new wxSize((wxSize &)(result));
39798 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39799 }
39800 return resultobj;
39801 fail:
39802 return NULL;
39803 }
39804
39805
39806 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39807 PyObject *resultobj;
39808 wxSizer *arg1 = (wxSizer *) 0 ;
39809 wxWindow *arg2 = (wxWindow *) 0 ;
39810 PyObject * obj0 = 0 ;
39811 PyObject * obj1 = 0 ;
39812 char *kwnames[] = {
39813 (char *) "self",(char *) "window", NULL
39814 };
39815
39816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39820 if (SWIG_arg_fail(2)) SWIG_fail;
39821 {
39822 PyThreadState* __tstate = wxPyBeginAllowThreads();
39823 (arg1)->FitInside(arg2);
39824
39825 wxPyEndAllowThreads(__tstate);
39826 if (PyErr_Occurred()) SWIG_fail;
39827 }
39828 Py_INCREF(Py_None); resultobj = Py_None;
39829 return resultobj;
39830 fail:
39831 return NULL;
39832 }
39833
39834
39835 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39836 PyObject *resultobj;
39837 wxSizer *arg1 = (wxSizer *) 0 ;
39838 wxWindow *arg2 = (wxWindow *) 0 ;
39839 PyObject * obj0 = 0 ;
39840 PyObject * obj1 = 0 ;
39841 char *kwnames[] = {
39842 (char *) "self",(char *) "window", NULL
39843 };
39844
39845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39847 if (SWIG_arg_fail(1)) SWIG_fail;
39848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39849 if (SWIG_arg_fail(2)) SWIG_fail;
39850 {
39851 PyThreadState* __tstate = wxPyBeginAllowThreads();
39852 (arg1)->SetSizeHints(arg2);
39853
39854 wxPyEndAllowThreads(__tstate);
39855 if (PyErr_Occurred()) SWIG_fail;
39856 }
39857 Py_INCREF(Py_None); resultobj = Py_None;
39858 return resultobj;
39859 fail:
39860 return NULL;
39861 }
39862
39863
39864 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39865 PyObject *resultobj;
39866 wxSizer *arg1 = (wxSizer *) 0 ;
39867 wxWindow *arg2 = (wxWindow *) 0 ;
39868 PyObject * obj0 = 0 ;
39869 PyObject * obj1 = 0 ;
39870 char *kwnames[] = {
39871 (char *) "self",(char *) "window", NULL
39872 };
39873
39874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39876 if (SWIG_arg_fail(1)) SWIG_fail;
39877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39878 if (SWIG_arg_fail(2)) SWIG_fail;
39879 {
39880 PyThreadState* __tstate = wxPyBeginAllowThreads();
39881 (arg1)->SetVirtualSizeHints(arg2);
39882
39883 wxPyEndAllowThreads(__tstate);
39884 if (PyErr_Occurred()) SWIG_fail;
39885 }
39886 Py_INCREF(Py_None); resultobj = Py_None;
39887 return resultobj;
39888 fail:
39889 return NULL;
39890 }
39891
39892
39893 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39894 PyObject *resultobj;
39895 wxSizer *arg1 = (wxSizer *) 0 ;
39896 bool arg2 = (bool) false ;
39897 PyObject * obj0 = 0 ;
39898 PyObject * obj1 = 0 ;
39899 char *kwnames[] = {
39900 (char *) "self",(char *) "deleteWindows", NULL
39901 };
39902
39903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39905 if (SWIG_arg_fail(1)) SWIG_fail;
39906 if (obj1) {
39907 {
39908 arg2 = (bool)(SWIG_As_bool(obj1));
39909 if (SWIG_arg_fail(2)) SWIG_fail;
39910 }
39911 }
39912 {
39913 PyThreadState* __tstate = wxPyBeginAllowThreads();
39914 (arg1)->Clear(arg2);
39915
39916 wxPyEndAllowThreads(__tstate);
39917 if (PyErr_Occurred()) SWIG_fail;
39918 }
39919 Py_INCREF(Py_None); resultobj = Py_None;
39920 return resultobj;
39921 fail:
39922 return NULL;
39923 }
39924
39925
39926 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39927 PyObject *resultobj;
39928 wxSizer *arg1 = (wxSizer *) 0 ;
39929 PyObject * obj0 = 0 ;
39930 char *kwnames[] = {
39931 (char *) "self", NULL
39932 };
39933
39934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39936 if (SWIG_arg_fail(1)) SWIG_fail;
39937 {
39938 PyThreadState* __tstate = wxPyBeginAllowThreads();
39939 (arg1)->DeleteWindows();
39940
39941 wxPyEndAllowThreads(__tstate);
39942 if (PyErr_Occurred()) SWIG_fail;
39943 }
39944 Py_INCREF(Py_None); resultobj = Py_None;
39945 return resultobj;
39946 fail:
39947 return NULL;
39948 }
39949
39950
39951 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39952 PyObject *resultobj;
39953 wxSizer *arg1 = (wxSizer *) 0 ;
39954 PyObject *result;
39955 PyObject * obj0 = 0 ;
39956 char *kwnames[] = {
39957 (char *) "self", NULL
39958 };
39959
39960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39962 if (SWIG_arg_fail(1)) SWIG_fail;
39963 {
39964 PyThreadState* __tstate = wxPyBeginAllowThreads();
39965 result = (PyObject *)wxSizer_GetChildren(arg1);
39966
39967 wxPyEndAllowThreads(__tstate);
39968 if (PyErr_Occurred()) SWIG_fail;
39969 }
39970 resultobj = result;
39971 return resultobj;
39972 fail:
39973 return NULL;
39974 }
39975
39976
39977 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39978 PyObject *resultobj;
39979 wxSizer *arg1 = (wxSizer *) 0 ;
39980 PyObject *arg2 = (PyObject *) 0 ;
39981 bool arg3 = (bool) true ;
39982 bool arg4 = (bool) false ;
39983 bool result;
39984 PyObject * obj0 = 0 ;
39985 PyObject * obj1 = 0 ;
39986 PyObject * obj2 = 0 ;
39987 PyObject * obj3 = 0 ;
39988 char *kwnames[] = {
39989 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39990 };
39991
39992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = obj1;
39996 if (obj2) {
39997 {
39998 arg3 = (bool)(SWIG_As_bool(obj2));
39999 if (SWIG_arg_fail(3)) SWIG_fail;
40000 }
40001 }
40002 if (obj3) {
40003 {
40004 arg4 = (bool)(SWIG_As_bool(obj3));
40005 if (SWIG_arg_fail(4)) SWIG_fail;
40006 }
40007 }
40008 {
40009 PyThreadState* __tstate = wxPyBeginAllowThreads();
40010 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40011
40012 wxPyEndAllowThreads(__tstate);
40013 if (PyErr_Occurred()) SWIG_fail;
40014 }
40015 {
40016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40017 }
40018 return resultobj;
40019 fail:
40020 return NULL;
40021 }
40022
40023
40024 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40025 PyObject *resultobj;
40026 wxSizer *arg1 = (wxSizer *) 0 ;
40027 PyObject *arg2 = (PyObject *) 0 ;
40028 bool result;
40029 PyObject * obj0 = 0 ;
40030 PyObject * obj1 = 0 ;
40031 char *kwnames[] = {
40032 (char *) "self",(char *) "item", NULL
40033 };
40034
40035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40037 if (SWIG_arg_fail(1)) SWIG_fail;
40038 arg2 = obj1;
40039 {
40040 PyThreadState* __tstate = wxPyBeginAllowThreads();
40041 result = (bool)wxSizer_IsShown(arg1,arg2);
40042
40043 wxPyEndAllowThreads(__tstate);
40044 if (PyErr_Occurred()) SWIG_fail;
40045 }
40046 {
40047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40048 }
40049 return resultobj;
40050 fail:
40051 return NULL;
40052 }
40053
40054
40055 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40056 PyObject *resultobj;
40057 wxSizer *arg1 = (wxSizer *) 0 ;
40058 bool arg2 ;
40059 PyObject * obj0 = 0 ;
40060 PyObject * obj1 = 0 ;
40061 char *kwnames[] = {
40062 (char *) "self",(char *) "show", NULL
40063 };
40064
40065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40067 if (SWIG_arg_fail(1)) SWIG_fail;
40068 {
40069 arg2 = (bool)(SWIG_As_bool(obj1));
40070 if (SWIG_arg_fail(2)) SWIG_fail;
40071 }
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 (arg1)->ShowItems(arg2);
40075
40076 wxPyEndAllowThreads(__tstate);
40077 if (PyErr_Occurred()) SWIG_fail;
40078 }
40079 Py_INCREF(Py_None); resultobj = Py_None;
40080 return resultobj;
40081 fail:
40082 return NULL;
40083 }
40084
40085
40086 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40087 PyObject *obj;
40088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40089 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40090 Py_INCREF(obj);
40091 return Py_BuildValue((char *)"");
40092 }
40093 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40094 PyObject *resultobj;
40095 wxPySizer *result;
40096 char *kwnames[] = {
40097 NULL
40098 };
40099
40100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40101 {
40102 PyThreadState* __tstate = wxPyBeginAllowThreads();
40103 result = (wxPySizer *)new wxPySizer();
40104
40105 wxPyEndAllowThreads(__tstate);
40106 if (PyErr_Occurred()) SWIG_fail;
40107 }
40108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40109 return resultobj;
40110 fail:
40111 return NULL;
40112 }
40113
40114
40115 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40116 PyObject *resultobj;
40117 wxPySizer *arg1 = (wxPySizer *) 0 ;
40118 PyObject *arg2 = (PyObject *) 0 ;
40119 PyObject *arg3 = (PyObject *) 0 ;
40120 PyObject * obj0 = 0 ;
40121 PyObject * obj1 = 0 ;
40122 PyObject * obj2 = 0 ;
40123 char *kwnames[] = {
40124 (char *) "self",(char *) "self",(char *) "_class", NULL
40125 };
40126
40127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40129 if (SWIG_arg_fail(1)) SWIG_fail;
40130 arg2 = obj1;
40131 arg3 = obj2;
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 (arg1)->_setCallbackInfo(arg2,arg3);
40135
40136 wxPyEndAllowThreads(__tstate);
40137 if (PyErr_Occurred()) SWIG_fail;
40138 }
40139 Py_INCREF(Py_None); resultobj = Py_None;
40140 return resultobj;
40141 fail:
40142 return NULL;
40143 }
40144
40145
40146 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40147 PyObject *obj;
40148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40149 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40150 Py_INCREF(obj);
40151 return Py_BuildValue((char *)"");
40152 }
40153 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40154 PyObject *resultobj;
40155 int arg1 = (int) wxHORIZONTAL ;
40156 wxBoxSizer *result;
40157 PyObject * obj0 = 0 ;
40158 char *kwnames[] = {
40159 (char *) "orient", NULL
40160 };
40161
40162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40163 if (obj0) {
40164 {
40165 arg1 = (int)(SWIG_As_int(obj0));
40166 if (SWIG_arg_fail(1)) SWIG_fail;
40167 }
40168 }
40169 {
40170 PyThreadState* __tstate = wxPyBeginAllowThreads();
40171 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40172
40173 wxPyEndAllowThreads(__tstate);
40174 if (PyErr_Occurred()) SWIG_fail;
40175 }
40176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40177 return resultobj;
40178 fail:
40179 return NULL;
40180 }
40181
40182
40183 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40184 PyObject *resultobj;
40185 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40186 int result;
40187 PyObject * obj0 = 0 ;
40188 char *kwnames[] = {
40189 (char *) "self", NULL
40190 };
40191
40192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40194 if (SWIG_arg_fail(1)) SWIG_fail;
40195 {
40196 PyThreadState* __tstate = wxPyBeginAllowThreads();
40197 result = (int)(arg1)->GetOrientation();
40198
40199 wxPyEndAllowThreads(__tstate);
40200 if (PyErr_Occurred()) SWIG_fail;
40201 }
40202 {
40203 resultobj = SWIG_From_int((int)(result));
40204 }
40205 return resultobj;
40206 fail:
40207 return NULL;
40208 }
40209
40210
40211 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40212 PyObject *resultobj;
40213 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40214 int arg2 ;
40215 PyObject * obj0 = 0 ;
40216 PyObject * obj1 = 0 ;
40217 char *kwnames[] = {
40218 (char *) "self",(char *) "orient", NULL
40219 };
40220
40221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40223 if (SWIG_arg_fail(1)) SWIG_fail;
40224 {
40225 arg2 = (int)(SWIG_As_int(obj1));
40226 if (SWIG_arg_fail(2)) SWIG_fail;
40227 }
40228 {
40229 PyThreadState* __tstate = wxPyBeginAllowThreads();
40230 (arg1)->SetOrientation(arg2);
40231
40232 wxPyEndAllowThreads(__tstate);
40233 if (PyErr_Occurred()) SWIG_fail;
40234 }
40235 Py_INCREF(Py_None); resultobj = Py_None;
40236 return resultobj;
40237 fail:
40238 return NULL;
40239 }
40240
40241
40242 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40243 PyObject *obj;
40244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40245 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40246 Py_INCREF(obj);
40247 return Py_BuildValue((char *)"");
40248 }
40249 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40250 PyObject *resultobj;
40251 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40252 int arg2 = (int) wxHORIZONTAL ;
40253 wxStaticBoxSizer *result;
40254 PyObject * obj0 = 0 ;
40255 PyObject * obj1 = 0 ;
40256 char *kwnames[] = {
40257 (char *) "box",(char *) "orient", NULL
40258 };
40259
40260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40262 if (SWIG_arg_fail(1)) SWIG_fail;
40263 if (obj1) {
40264 {
40265 arg2 = (int)(SWIG_As_int(obj1));
40266 if (SWIG_arg_fail(2)) SWIG_fail;
40267 }
40268 }
40269 {
40270 PyThreadState* __tstate = wxPyBeginAllowThreads();
40271 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40272
40273 wxPyEndAllowThreads(__tstate);
40274 if (PyErr_Occurred()) SWIG_fail;
40275 }
40276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40277 return resultobj;
40278 fail:
40279 return NULL;
40280 }
40281
40282
40283 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40284 PyObject *resultobj;
40285 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40286 wxStaticBox *result;
40287 PyObject * obj0 = 0 ;
40288 char *kwnames[] = {
40289 (char *) "self", NULL
40290 };
40291
40292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40294 if (SWIG_arg_fail(1)) SWIG_fail;
40295 {
40296 PyThreadState* __tstate = wxPyBeginAllowThreads();
40297 result = (wxStaticBox *)(arg1)->GetStaticBox();
40298
40299 wxPyEndAllowThreads(__tstate);
40300 if (PyErr_Occurred()) SWIG_fail;
40301 }
40302 {
40303 resultobj = wxPyMake_wxObject(result, 0);
40304 }
40305 return resultobj;
40306 fail:
40307 return NULL;
40308 }
40309
40310
40311 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40312 PyObject *obj;
40313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40314 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40315 Py_INCREF(obj);
40316 return Py_BuildValue((char *)"");
40317 }
40318 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40319 PyObject *resultobj;
40320 int arg1 = (int) 1 ;
40321 int arg2 = (int) 0 ;
40322 int arg3 = (int) 0 ;
40323 int arg4 = (int) 0 ;
40324 wxGridSizer *result;
40325 PyObject * obj0 = 0 ;
40326 PyObject * obj1 = 0 ;
40327 PyObject * obj2 = 0 ;
40328 PyObject * obj3 = 0 ;
40329 char *kwnames[] = {
40330 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40331 };
40332
40333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40334 if (obj0) {
40335 {
40336 arg1 = (int)(SWIG_As_int(obj0));
40337 if (SWIG_arg_fail(1)) SWIG_fail;
40338 }
40339 }
40340 if (obj1) {
40341 {
40342 arg2 = (int)(SWIG_As_int(obj1));
40343 if (SWIG_arg_fail(2)) SWIG_fail;
40344 }
40345 }
40346 if (obj2) {
40347 {
40348 arg3 = (int)(SWIG_As_int(obj2));
40349 if (SWIG_arg_fail(3)) SWIG_fail;
40350 }
40351 }
40352 if (obj3) {
40353 {
40354 arg4 = (int)(SWIG_As_int(obj3));
40355 if (SWIG_arg_fail(4)) SWIG_fail;
40356 }
40357 }
40358 {
40359 PyThreadState* __tstate = wxPyBeginAllowThreads();
40360 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40361
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40366 return resultobj;
40367 fail:
40368 return NULL;
40369 }
40370
40371
40372 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40373 PyObject *resultobj;
40374 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40375 int arg2 ;
40376 PyObject * obj0 = 0 ;
40377 PyObject * obj1 = 0 ;
40378 char *kwnames[] = {
40379 (char *) "self",(char *) "cols", NULL
40380 };
40381
40382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40384 if (SWIG_arg_fail(1)) SWIG_fail;
40385 {
40386 arg2 = (int)(SWIG_As_int(obj1));
40387 if (SWIG_arg_fail(2)) SWIG_fail;
40388 }
40389 {
40390 PyThreadState* __tstate = wxPyBeginAllowThreads();
40391 (arg1)->SetCols(arg2);
40392
40393 wxPyEndAllowThreads(__tstate);
40394 if (PyErr_Occurred()) SWIG_fail;
40395 }
40396 Py_INCREF(Py_None); resultobj = Py_None;
40397 return resultobj;
40398 fail:
40399 return NULL;
40400 }
40401
40402
40403 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40404 PyObject *resultobj;
40405 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40406 int arg2 ;
40407 PyObject * obj0 = 0 ;
40408 PyObject * obj1 = 0 ;
40409 char *kwnames[] = {
40410 (char *) "self",(char *) "rows", NULL
40411 };
40412
40413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40415 if (SWIG_arg_fail(1)) SWIG_fail;
40416 {
40417 arg2 = (int)(SWIG_As_int(obj1));
40418 if (SWIG_arg_fail(2)) SWIG_fail;
40419 }
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 (arg1)->SetRows(arg2);
40423
40424 wxPyEndAllowThreads(__tstate);
40425 if (PyErr_Occurred()) SWIG_fail;
40426 }
40427 Py_INCREF(Py_None); resultobj = Py_None;
40428 return resultobj;
40429 fail:
40430 return NULL;
40431 }
40432
40433
40434 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40435 PyObject *resultobj;
40436 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40437 int arg2 ;
40438 PyObject * obj0 = 0 ;
40439 PyObject * obj1 = 0 ;
40440 char *kwnames[] = {
40441 (char *) "self",(char *) "gap", NULL
40442 };
40443
40444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40446 if (SWIG_arg_fail(1)) SWIG_fail;
40447 {
40448 arg2 = (int)(SWIG_As_int(obj1));
40449 if (SWIG_arg_fail(2)) SWIG_fail;
40450 }
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 (arg1)->SetVGap(arg2);
40454
40455 wxPyEndAllowThreads(__tstate);
40456 if (PyErr_Occurred()) SWIG_fail;
40457 }
40458 Py_INCREF(Py_None); resultobj = Py_None;
40459 return resultobj;
40460 fail:
40461 return NULL;
40462 }
40463
40464
40465 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40466 PyObject *resultobj;
40467 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40468 int arg2 ;
40469 PyObject * obj0 = 0 ;
40470 PyObject * obj1 = 0 ;
40471 char *kwnames[] = {
40472 (char *) "self",(char *) "gap", NULL
40473 };
40474
40475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40477 if (SWIG_arg_fail(1)) SWIG_fail;
40478 {
40479 arg2 = (int)(SWIG_As_int(obj1));
40480 if (SWIG_arg_fail(2)) SWIG_fail;
40481 }
40482 {
40483 PyThreadState* __tstate = wxPyBeginAllowThreads();
40484 (arg1)->SetHGap(arg2);
40485
40486 wxPyEndAllowThreads(__tstate);
40487 if (PyErr_Occurred()) SWIG_fail;
40488 }
40489 Py_INCREF(Py_None); resultobj = Py_None;
40490 return resultobj;
40491 fail:
40492 return NULL;
40493 }
40494
40495
40496 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40497 PyObject *resultobj;
40498 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40499 int result;
40500 PyObject * obj0 = 0 ;
40501 char *kwnames[] = {
40502 (char *) "self", NULL
40503 };
40504
40505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40507 if (SWIG_arg_fail(1)) SWIG_fail;
40508 {
40509 PyThreadState* __tstate = wxPyBeginAllowThreads();
40510 result = (int)(arg1)->GetCols();
40511
40512 wxPyEndAllowThreads(__tstate);
40513 if (PyErr_Occurred()) SWIG_fail;
40514 }
40515 {
40516 resultobj = SWIG_From_int((int)(result));
40517 }
40518 return resultobj;
40519 fail:
40520 return NULL;
40521 }
40522
40523
40524 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40525 PyObject *resultobj;
40526 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40527 int result;
40528 PyObject * obj0 = 0 ;
40529 char *kwnames[] = {
40530 (char *) "self", NULL
40531 };
40532
40533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40535 if (SWIG_arg_fail(1)) SWIG_fail;
40536 {
40537 PyThreadState* __tstate = wxPyBeginAllowThreads();
40538 result = (int)(arg1)->GetRows();
40539
40540 wxPyEndAllowThreads(__tstate);
40541 if (PyErr_Occurred()) SWIG_fail;
40542 }
40543 {
40544 resultobj = SWIG_From_int((int)(result));
40545 }
40546 return resultobj;
40547 fail:
40548 return NULL;
40549 }
40550
40551
40552 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40553 PyObject *resultobj;
40554 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40555 int result;
40556 PyObject * obj0 = 0 ;
40557 char *kwnames[] = {
40558 (char *) "self", NULL
40559 };
40560
40561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40563 if (SWIG_arg_fail(1)) SWIG_fail;
40564 {
40565 PyThreadState* __tstate = wxPyBeginAllowThreads();
40566 result = (int)(arg1)->GetVGap();
40567
40568 wxPyEndAllowThreads(__tstate);
40569 if (PyErr_Occurred()) SWIG_fail;
40570 }
40571 {
40572 resultobj = SWIG_From_int((int)(result));
40573 }
40574 return resultobj;
40575 fail:
40576 return NULL;
40577 }
40578
40579
40580 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40581 PyObject *resultobj;
40582 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40583 int result;
40584 PyObject * obj0 = 0 ;
40585 char *kwnames[] = {
40586 (char *) "self", NULL
40587 };
40588
40589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40591 if (SWIG_arg_fail(1)) SWIG_fail;
40592 {
40593 PyThreadState* __tstate = wxPyBeginAllowThreads();
40594 result = (int)(arg1)->GetHGap();
40595
40596 wxPyEndAllowThreads(__tstate);
40597 if (PyErr_Occurred()) SWIG_fail;
40598 }
40599 {
40600 resultobj = SWIG_From_int((int)(result));
40601 }
40602 return resultobj;
40603 fail:
40604 return NULL;
40605 }
40606
40607
40608 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40609 PyObject *obj;
40610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40611 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40612 Py_INCREF(obj);
40613 return Py_BuildValue((char *)"");
40614 }
40615 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40616 PyObject *resultobj;
40617 int arg1 = (int) 1 ;
40618 int arg2 = (int) 0 ;
40619 int arg3 = (int) 0 ;
40620 int arg4 = (int) 0 ;
40621 wxFlexGridSizer *result;
40622 PyObject * obj0 = 0 ;
40623 PyObject * obj1 = 0 ;
40624 PyObject * obj2 = 0 ;
40625 PyObject * obj3 = 0 ;
40626 char *kwnames[] = {
40627 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40628 };
40629
40630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40631 if (obj0) {
40632 {
40633 arg1 = (int)(SWIG_As_int(obj0));
40634 if (SWIG_arg_fail(1)) SWIG_fail;
40635 }
40636 }
40637 if (obj1) {
40638 {
40639 arg2 = (int)(SWIG_As_int(obj1));
40640 if (SWIG_arg_fail(2)) SWIG_fail;
40641 }
40642 }
40643 if (obj2) {
40644 {
40645 arg3 = (int)(SWIG_As_int(obj2));
40646 if (SWIG_arg_fail(3)) SWIG_fail;
40647 }
40648 }
40649 if (obj3) {
40650 {
40651 arg4 = (int)(SWIG_As_int(obj3));
40652 if (SWIG_arg_fail(4)) SWIG_fail;
40653 }
40654 }
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40658
40659 wxPyEndAllowThreads(__tstate);
40660 if (PyErr_Occurred()) SWIG_fail;
40661 }
40662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40663 return resultobj;
40664 fail:
40665 return NULL;
40666 }
40667
40668
40669 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40670 PyObject *resultobj;
40671 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40672 size_t arg2 ;
40673 int arg3 = (int) 0 ;
40674 PyObject * obj0 = 0 ;
40675 PyObject * obj1 = 0 ;
40676 PyObject * obj2 = 0 ;
40677 char *kwnames[] = {
40678 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40679 };
40680
40681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40683 if (SWIG_arg_fail(1)) SWIG_fail;
40684 {
40685 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40686 if (SWIG_arg_fail(2)) SWIG_fail;
40687 }
40688 if (obj2) {
40689 {
40690 arg3 = (int)(SWIG_As_int(obj2));
40691 if (SWIG_arg_fail(3)) SWIG_fail;
40692 }
40693 }
40694 {
40695 PyThreadState* __tstate = wxPyBeginAllowThreads();
40696 (arg1)->AddGrowableRow(arg2,arg3);
40697
40698 wxPyEndAllowThreads(__tstate);
40699 if (PyErr_Occurred()) SWIG_fail;
40700 }
40701 Py_INCREF(Py_None); resultobj = Py_None;
40702 return resultobj;
40703 fail:
40704 return NULL;
40705 }
40706
40707
40708 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40709 PyObject *resultobj;
40710 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40711 size_t arg2 ;
40712 PyObject * obj0 = 0 ;
40713 PyObject * obj1 = 0 ;
40714 char *kwnames[] = {
40715 (char *) "self",(char *) "idx", NULL
40716 };
40717
40718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40720 if (SWIG_arg_fail(1)) SWIG_fail;
40721 {
40722 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40723 if (SWIG_arg_fail(2)) SWIG_fail;
40724 }
40725 {
40726 PyThreadState* __tstate = wxPyBeginAllowThreads();
40727 (arg1)->RemoveGrowableRow(arg2);
40728
40729 wxPyEndAllowThreads(__tstate);
40730 if (PyErr_Occurred()) SWIG_fail;
40731 }
40732 Py_INCREF(Py_None); resultobj = Py_None;
40733 return resultobj;
40734 fail:
40735 return NULL;
40736 }
40737
40738
40739 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40740 PyObject *resultobj;
40741 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40742 size_t arg2 ;
40743 int arg3 = (int) 0 ;
40744 PyObject * obj0 = 0 ;
40745 PyObject * obj1 = 0 ;
40746 PyObject * obj2 = 0 ;
40747 char *kwnames[] = {
40748 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40749 };
40750
40751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40753 if (SWIG_arg_fail(1)) SWIG_fail;
40754 {
40755 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40756 if (SWIG_arg_fail(2)) SWIG_fail;
40757 }
40758 if (obj2) {
40759 {
40760 arg3 = (int)(SWIG_As_int(obj2));
40761 if (SWIG_arg_fail(3)) SWIG_fail;
40762 }
40763 }
40764 {
40765 PyThreadState* __tstate = wxPyBeginAllowThreads();
40766 (arg1)->AddGrowableCol(arg2,arg3);
40767
40768 wxPyEndAllowThreads(__tstate);
40769 if (PyErr_Occurred()) SWIG_fail;
40770 }
40771 Py_INCREF(Py_None); resultobj = Py_None;
40772 return resultobj;
40773 fail:
40774 return NULL;
40775 }
40776
40777
40778 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40779 PyObject *resultobj;
40780 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40781 size_t arg2 ;
40782 PyObject * obj0 = 0 ;
40783 PyObject * obj1 = 0 ;
40784 char *kwnames[] = {
40785 (char *) "self",(char *) "idx", NULL
40786 };
40787
40788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40790 if (SWIG_arg_fail(1)) SWIG_fail;
40791 {
40792 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40793 if (SWIG_arg_fail(2)) SWIG_fail;
40794 }
40795 {
40796 PyThreadState* __tstate = wxPyBeginAllowThreads();
40797 (arg1)->RemoveGrowableCol(arg2);
40798
40799 wxPyEndAllowThreads(__tstate);
40800 if (PyErr_Occurred()) SWIG_fail;
40801 }
40802 Py_INCREF(Py_None); resultobj = Py_None;
40803 return resultobj;
40804 fail:
40805 return NULL;
40806 }
40807
40808
40809 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40810 PyObject *resultobj;
40811 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40812 int arg2 ;
40813 PyObject * obj0 = 0 ;
40814 PyObject * obj1 = 0 ;
40815 char *kwnames[] = {
40816 (char *) "self",(char *) "direction", NULL
40817 };
40818
40819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40821 if (SWIG_arg_fail(1)) SWIG_fail;
40822 {
40823 arg2 = (int)(SWIG_As_int(obj1));
40824 if (SWIG_arg_fail(2)) SWIG_fail;
40825 }
40826 {
40827 PyThreadState* __tstate = wxPyBeginAllowThreads();
40828 (arg1)->SetFlexibleDirection(arg2);
40829
40830 wxPyEndAllowThreads(__tstate);
40831 if (PyErr_Occurred()) SWIG_fail;
40832 }
40833 Py_INCREF(Py_None); resultobj = Py_None;
40834 return resultobj;
40835 fail:
40836 return NULL;
40837 }
40838
40839
40840 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40841 PyObject *resultobj;
40842 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40843 int result;
40844 PyObject * obj0 = 0 ;
40845 char *kwnames[] = {
40846 (char *) "self", NULL
40847 };
40848
40849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40851 if (SWIG_arg_fail(1)) SWIG_fail;
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 result = (int)(arg1)->GetFlexibleDirection();
40855
40856 wxPyEndAllowThreads(__tstate);
40857 if (PyErr_Occurred()) SWIG_fail;
40858 }
40859 {
40860 resultobj = SWIG_From_int((int)(result));
40861 }
40862 return resultobj;
40863 fail:
40864 return NULL;
40865 }
40866
40867
40868 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40869 PyObject *resultobj;
40870 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40871 wxFlexSizerGrowMode arg2 ;
40872 PyObject * obj0 = 0 ;
40873 PyObject * obj1 = 0 ;
40874 char *kwnames[] = {
40875 (char *) "self",(char *) "mode", NULL
40876 };
40877
40878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40880 if (SWIG_arg_fail(1)) SWIG_fail;
40881 {
40882 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40883 if (SWIG_arg_fail(2)) SWIG_fail;
40884 }
40885 {
40886 PyThreadState* __tstate = wxPyBeginAllowThreads();
40887 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40888
40889 wxPyEndAllowThreads(__tstate);
40890 if (PyErr_Occurred()) SWIG_fail;
40891 }
40892 Py_INCREF(Py_None); resultobj = Py_None;
40893 return resultobj;
40894 fail:
40895 return NULL;
40896 }
40897
40898
40899 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40900 PyObject *resultobj;
40901 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40902 wxFlexSizerGrowMode result;
40903 PyObject * obj0 = 0 ;
40904 char *kwnames[] = {
40905 (char *) "self", NULL
40906 };
40907
40908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40910 if (SWIG_arg_fail(1)) SWIG_fail;
40911 {
40912 PyThreadState* __tstate = wxPyBeginAllowThreads();
40913 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40914
40915 wxPyEndAllowThreads(__tstate);
40916 if (PyErr_Occurred()) SWIG_fail;
40917 }
40918 resultobj = SWIG_From_int((result));
40919 return resultobj;
40920 fail:
40921 return NULL;
40922 }
40923
40924
40925 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40926 PyObject *resultobj;
40927 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40928 wxArrayInt *result;
40929 PyObject * obj0 = 0 ;
40930 char *kwnames[] = {
40931 (char *) "self", NULL
40932 };
40933
40934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40936 if (SWIG_arg_fail(1)) SWIG_fail;
40937 {
40938 PyThreadState* __tstate = wxPyBeginAllowThreads();
40939 {
40940 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40941 result = (wxArrayInt *) &_result_ref;
40942 }
40943
40944 wxPyEndAllowThreads(__tstate);
40945 if (PyErr_Occurred()) SWIG_fail;
40946 }
40947 {
40948 resultobj = PyList_New(0);
40949 size_t idx;
40950 for (idx = 0; idx < result->GetCount(); idx += 1) {
40951 PyObject* val = PyInt_FromLong( result->Item(idx) );
40952 PyList_Append(resultobj, val);
40953 Py_DECREF(val);
40954 }
40955 }
40956 return resultobj;
40957 fail:
40958 return NULL;
40959 }
40960
40961
40962 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40963 PyObject *resultobj;
40964 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40965 wxArrayInt *result;
40966 PyObject * obj0 = 0 ;
40967 char *kwnames[] = {
40968 (char *) "self", NULL
40969 };
40970
40971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40973 if (SWIG_arg_fail(1)) SWIG_fail;
40974 {
40975 PyThreadState* __tstate = wxPyBeginAllowThreads();
40976 {
40977 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40978 result = (wxArrayInt *) &_result_ref;
40979 }
40980
40981 wxPyEndAllowThreads(__tstate);
40982 if (PyErr_Occurred()) SWIG_fail;
40983 }
40984 {
40985 resultobj = PyList_New(0);
40986 size_t idx;
40987 for (idx = 0; idx < result->GetCount(); idx += 1) {
40988 PyObject* val = PyInt_FromLong( result->Item(idx) );
40989 PyList_Append(resultobj, val);
40990 Py_DECREF(val);
40991 }
40992 }
40993 return resultobj;
40994 fail:
40995 return NULL;
40996 }
40997
40998
40999 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41000 PyObject *obj;
41001 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41002 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41003 Py_INCREF(obj);
41004 return Py_BuildValue((char *)"");
41005 }
41006 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41007 PyObject *resultobj;
41008 wxStdDialogButtonSizer *result;
41009 char *kwnames[] = {
41010 NULL
41011 };
41012
41013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41014 {
41015 PyThreadState* __tstate = wxPyBeginAllowThreads();
41016 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41017
41018 wxPyEndAllowThreads(__tstate);
41019 if (PyErr_Occurred()) SWIG_fail;
41020 }
41021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41022 return resultobj;
41023 fail:
41024 return NULL;
41025 }
41026
41027
41028 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41029 PyObject *resultobj;
41030 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41031 wxButton *arg2 = (wxButton *) 0 ;
41032 PyObject * obj0 = 0 ;
41033 PyObject * obj1 = 0 ;
41034 char *kwnames[] = {
41035 (char *) "self",(char *) "button", NULL
41036 };
41037
41038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41040 if (SWIG_arg_fail(1)) SWIG_fail;
41041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41042 if (SWIG_arg_fail(2)) SWIG_fail;
41043 {
41044 PyThreadState* __tstate = wxPyBeginAllowThreads();
41045 (arg1)->AddButton(arg2);
41046
41047 wxPyEndAllowThreads(__tstate);
41048 if (PyErr_Occurred()) SWIG_fail;
41049 }
41050 Py_INCREF(Py_None); resultobj = Py_None;
41051 return resultobj;
41052 fail:
41053 return NULL;
41054 }
41055
41056
41057 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41058 PyObject *resultobj;
41059 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41060 PyObject * obj0 = 0 ;
41061 char *kwnames[] = {
41062 (char *) "self", NULL
41063 };
41064
41065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41067 if (SWIG_arg_fail(1)) SWIG_fail;
41068 {
41069 PyThreadState* __tstate = wxPyBeginAllowThreads();
41070 (arg1)->Realize();
41071
41072 wxPyEndAllowThreads(__tstate);
41073 if (PyErr_Occurred()) SWIG_fail;
41074 }
41075 Py_INCREF(Py_None); resultobj = Py_None;
41076 return resultobj;
41077 fail:
41078 return NULL;
41079 }
41080
41081
41082 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41083 PyObject *resultobj;
41084 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41085 wxButton *arg2 = (wxButton *) 0 ;
41086 PyObject * obj0 = 0 ;
41087 PyObject * obj1 = 0 ;
41088 char *kwnames[] = {
41089 (char *) "self",(char *) "button", NULL
41090 };
41091
41092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41094 if (SWIG_arg_fail(1)) SWIG_fail;
41095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41096 if (SWIG_arg_fail(2)) SWIG_fail;
41097 {
41098 PyThreadState* __tstate = wxPyBeginAllowThreads();
41099 (arg1)->SetAffirmativeButton(arg2);
41100
41101 wxPyEndAllowThreads(__tstate);
41102 if (PyErr_Occurred()) SWIG_fail;
41103 }
41104 Py_INCREF(Py_None); resultobj = Py_None;
41105 return resultobj;
41106 fail:
41107 return NULL;
41108 }
41109
41110
41111 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41112 PyObject *resultobj;
41113 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41114 wxButton *arg2 = (wxButton *) 0 ;
41115 PyObject * obj0 = 0 ;
41116 PyObject * obj1 = 0 ;
41117 char *kwnames[] = {
41118 (char *) "self",(char *) "button", NULL
41119 };
41120
41121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41123 if (SWIG_arg_fail(1)) SWIG_fail;
41124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41125 if (SWIG_arg_fail(2)) SWIG_fail;
41126 {
41127 PyThreadState* __tstate = wxPyBeginAllowThreads();
41128 (arg1)->SetNegativeButton(arg2);
41129
41130 wxPyEndAllowThreads(__tstate);
41131 if (PyErr_Occurred()) SWIG_fail;
41132 }
41133 Py_INCREF(Py_None); resultobj = Py_None;
41134 return resultobj;
41135 fail:
41136 return NULL;
41137 }
41138
41139
41140 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41141 PyObject *resultobj;
41142 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41143 wxButton *arg2 = (wxButton *) 0 ;
41144 PyObject * obj0 = 0 ;
41145 PyObject * obj1 = 0 ;
41146 char *kwnames[] = {
41147 (char *) "self",(char *) "button", NULL
41148 };
41149
41150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41152 if (SWIG_arg_fail(1)) SWIG_fail;
41153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41154 if (SWIG_arg_fail(2)) SWIG_fail;
41155 {
41156 PyThreadState* __tstate = wxPyBeginAllowThreads();
41157 (arg1)->SetCancelButton(arg2);
41158
41159 wxPyEndAllowThreads(__tstate);
41160 if (PyErr_Occurred()) SWIG_fail;
41161 }
41162 Py_INCREF(Py_None); resultobj = Py_None;
41163 return resultobj;
41164 fail:
41165 return NULL;
41166 }
41167
41168
41169 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41170 PyObject *resultobj;
41171 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41172 wxButton *result;
41173 PyObject * obj0 = 0 ;
41174 char *kwnames[] = {
41175 (char *) "self", NULL
41176 };
41177
41178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41180 if (SWIG_arg_fail(1)) SWIG_fail;
41181 {
41182 PyThreadState* __tstate = wxPyBeginAllowThreads();
41183 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41184
41185 wxPyEndAllowThreads(__tstate);
41186 if (PyErr_Occurred()) SWIG_fail;
41187 }
41188 {
41189 resultobj = wxPyMake_wxObject(result, 0);
41190 }
41191 return resultobj;
41192 fail:
41193 return NULL;
41194 }
41195
41196
41197 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41198 PyObject *resultobj;
41199 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41200 wxButton *result;
41201 PyObject * obj0 = 0 ;
41202 char *kwnames[] = {
41203 (char *) "self", NULL
41204 };
41205
41206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41208 if (SWIG_arg_fail(1)) SWIG_fail;
41209 {
41210 PyThreadState* __tstate = wxPyBeginAllowThreads();
41211 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41212
41213 wxPyEndAllowThreads(__tstate);
41214 if (PyErr_Occurred()) SWIG_fail;
41215 }
41216 {
41217 resultobj = wxPyMake_wxObject(result, 0);
41218 }
41219 return resultobj;
41220 fail:
41221 return NULL;
41222 }
41223
41224
41225 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41226 PyObject *resultobj;
41227 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41228 wxButton *result;
41229 PyObject * obj0 = 0 ;
41230 char *kwnames[] = {
41231 (char *) "self", NULL
41232 };
41233
41234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41236 if (SWIG_arg_fail(1)) SWIG_fail;
41237 {
41238 PyThreadState* __tstate = wxPyBeginAllowThreads();
41239 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41240
41241 wxPyEndAllowThreads(__tstate);
41242 if (PyErr_Occurred()) SWIG_fail;
41243 }
41244 {
41245 resultobj = wxPyMake_wxObject(result, 0);
41246 }
41247 return resultobj;
41248 fail:
41249 return NULL;
41250 }
41251
41252
41253 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41254 PyObject *resultobj;
41255 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41256 wxButton *result;
41257 PyObject * obj0 = 0 ;
41258 char *kwnames[] = {
41259 (char *) "self", NULL
41260 };
41261
41262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41264 if (SWIG_arg_fail(1)) SWIG_fail;
41265 {
41266 PyThreadState* __tstate = wxPyBeginAllowThreads();
41267 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41268
41269 wxPyEndAllowThreads(__tstate);
41270 if (PyErr_Occurred()) SWIG_fail;
41271 }
41272 {
41273 resultobj = wxPyMake_wxObject(result, 0);
41274 }
41275 return resultobj;
41276 fail:
41277 return NULL;
41278 }
41279
41280
41281 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41282 PyObject *resultobj;
41283 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41284 wxButton *result;
41285 PyObject * obj0 = 0 ;
41286 char *kwnames[] = {
41287 (char *) "self", NULL
41288 };
41289
41290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41292 if (SWIG_arg_fail(1)) SWIG_fail;
41293 {
41294 PyThreadState* __tstate = wxPyBeginAllowThreads();
41295 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41296
41297 wxPyEndAllowThreads(__tstate);
41298 if (PyErr_Occurred()) SWIG_fail;
41299 }
41300 {
41301 resultobj = wxPyMake_wxObject(result, 0);
41302 }
41303 return resultobj;
41304 fail:
41305 return NULL;
41306 }
41307
41308
41309 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41310 PyObject *obj;
41311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41312 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41313 Py_INCREF(obj);
41314 return Py_BuildValue((char *)"");
41315 }
41316 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41317 PyObject *resultobj;
41318 int arg1 = (int) 0 ;
41319 int arg2 = (int) 0 ;
41320 wxGBPosition *result;
41321 PyObject * obj0 = 0 ;
41322 PyObject * obj1 = 0 ;
41323 char *kwnames[] = {
41324 (char *) "row",(char *) "col", NULL
41325 };
41326
41327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41328 if (obj0) {
41329 {
41330 arg1 = (int)(SWIG_As_int(obj0));
41331 if (SWIG_arg_fail(1)) SWIG_fail;
41332 }
41333 }
41334 if (obj1) {
41335 {
41336 arg2 = (int)(SWIG_As_int(obj1));
41337 if (SWIG_arg_fail(2)) SWIG_fail;
41338 }
41339 }
41340 {
41341 PyThreadState* __tstate = wxPyBeginAllowThreads();
41342 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41343
41344 wxPyEndAllowThreads(__tstate);
41345 if (PyErr_Occurred()) SWIG_fail;
41346 }
41347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41348 return resultobj;
41349 fail:
41350 return NULL;
41351 }
41352
41353
41354 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41355 PyObject *resultobj;
41356 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41357 int result;
41358 PyObject * obj0 = 0 ;
41359 char *kwnames[] = {
41360 (char *) "self", NULL
41361 };
41362
41363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41365 if (SWIG_arg_fail(1)) SWIG_fail;
41366 {
41367 PyThreadState* __tstate = wxPyBeginAllowThreads();
41368 result = (int)((wxGBPosition const *)arg1)->GetRow();
41369
41370 wxPyEndAllowThreads(__tstate);
41371 if (PyErr_Occurred()) SWIG_fail;
41372 }
41373 {
41374 resultobj = SWIG_From_int((int)(result));
41375 }
41376 return resultobj;
41377 fail:
41378 return NULL;
41379 }
41380
41381
41382 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41383 PyObject *resultobj;
41384 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41385 int result;
41386 PyObject * obj0 = 0 ;
41387 char *kwnames[] = {
41388 (char *) "self", NULL
41389 };
41390
41391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41393 if (SWIG_arg_fail(1)) SWIG_fail;
41394 {
41395 PyThreadState* __tstate = wxPyBeginAllowThreads();
41396 result = (int)((wxGBPosition const *)arg1)->GetCol();
41397
41398 wxPyEndAllowThreads(__tstate);
41399 if (PyErr_Occurred()) SWIG_fail;
41400 }
41401 {
41402 resultobj = SWIG_From_int((int)(result));
41403 }
41404 return resultobj;
41405 fail:
41406 return NULL;
41407 }
41408
41409
41410 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41411 PyObject *resultobj;
41412 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41413 int arg2 ;
41414 PyObject * obj0 = 0 ;
41415 PyObject * obj1 = 0 ;
41416 char *kwnames[] = {
41417 (char *) "self",(char *) "row", NULL
41418 };
41419
41420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41422 if (SWIG_arg_fail(1)) SWIG_fail;
41423 {
41424 arg2 = (int)(SWIG_As_int(obj1));
41425 if (SWIG_arg_fail(2)) SWIG_fail;
41426 }
41427 {
41428 PyThreadState* __tstate = wxPyBeginAllowThreads();
41429 (arg1)->SetRow(arg2);
41430
41431 wxPyEndAllowThreads(__tstate);
41432 if (PyErr_Occurred()) SWIG_fail;
41433 }
41434 Py_INCREF(Py_None); resultobj = Py_None;
41435 return resultobj;
41436 fail:
41437 return NULL;
41438 }
41439
41440
41441 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41442 PyObject *resultobj;
41443 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41444 int arg2 ;
41445 PyObject * obj0 = 0 ;
41446 PyObject * obj1 = 0 ;
41447 char *kwnames[] = {
41448 (char *) "self",(char *) "col", NULL
41449 };
41450
41451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41453 if (SWIG_arg_fail(1)) SWIG_fail;
41454 {
41455 arg2 = (int)(SWIG_As_int(obj1));
41456 if (SWIG_arg_fail(2)) SWIG_fail;
41457 }
41458 {
41459 PyThreadState* __tstate = wxPyBeginAllowThreads();
41460 (arg1)->SetCol(arg2);
41461
41462 wxPyEndAllowThreads(__tstate);
41463 if (PyErr_Occurred()) SWIG_fail;
41464 }
41465 Py_INCREF(Py_None); resultobj = Py_None;
41466 return resultobj;
41467 fail:
41468 return NULL;
41469 }
41470
41471
41472 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41473 PyObject *resultobj;
41474 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41475 wxGBPosition *arg2 = 0 ;
41476 bool result;
41477 wxGBPosition temp2 ;
41478 PyObject * obj0 = 0 ;
41479 PyObject * obj1 = 0 ;
41480 char *kwnames[] = {
41481 (char *) "self",(char *) "other", NULL
41482 };
41483
41484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41486 if (SWIG_arg_fail(1)) SWIG_fail;
41487 {
41488 arg2 = &temp2;
41489 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41490 }
41491 {
41492 PyThreadState* __tstate = wxPyBeginAllowThreads();
41493 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41494
41495 wxPyEndAllowThreads(__tstate);
41496 if (PyErr_Occurred()) SWIG_fail;
41497 }
41498 {
41499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41500 }
41501 return resultobj;
41502 fail:
41503 return NULL;
41504 }
41505
41506
41507 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41508 PyObject *resultobj;
41509 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41510 wxGBPosition *arg2 = 0 ;
41511 bool result;
41512 wxGBPosition temp2 ;
41513 PyObject * obj0 = 0 ;
41514 PyObject * obj1 = 0 ;
41515 char *kwnames[] = {
41516 (char *) "self",(char *) "other", NULL
41517 };
41518
41519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41521 if (SWIG_arg_fail(1)) SWIG_fail;
41522 {
41523 arg2 = &temp2;
41524 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41525 }
41526 {
41527 PyThreadState* __tstate = wxPyBeginAllowThreads();
41528 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41529
41530 wxPyEndAllowThreads(__tstate);
41531 if (PyErr_Occurred()) SWIG_fail;
41532 }
41533 {
41534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41535 }
41536 return resultobj;
41537 fail:
41538 return NULL;
41539 }
41540
41541
41542 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41543 PyObject *resultobj;
41544 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41545 int arg2 = (int) 0 ;
41546 int arg3 = (int) 0 ;
41547 PyObject * obj0 = 0 ;
41548 PyObject * obj1 = 0 ;
41549 PyObject * obj2 = 0 ;
41550 char *kwnames[] = {
41551 (char *) "self",(char *) "row",(char *) "col", NULL
41552 };
41553
41554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41556 if (SWIG_arg_fail(1)) SWIG_fail;
41557 if (obj1) {
41558 {
41559 arg2 = (int)(SWIG_As_int(obj1));
41560 if (SWIG_arg_fail(2)) SWIG_fail;
41561 }
41562 }
41563 if (obj2) {
41564 {
41565 arg3 = (int)(SWIG_As_int(obj2));
41566 if (SWIG_arg_fail(3)) SWIG_fail;
41567 }
41568 }
41569 {
41570 PyThreadState* __tstate = wxPyBeginAllowThreads();
41571 wxGBPosition_Set(arg1,arg2,arg3);
41572
41573 wxPyEndAllowThreads(__tstate);
41574 if (PyErr_Occurred()) SWIG_fail;
41575 }
41576 Py_INCREF(Py_None); resultobj = Py_None;
41577 return resultobj;
41578 fail:
41579 return NULL;
41580 }
41581
41582
41583 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41584 PyObject *resultobj;
41585 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41586 PyObject *result;
41587 PyObject * obj0 = 0 ;
41588 char *kwnames[] = {
41589 (char *) "self", NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(1)) SWIG_fail;
41595 {
41596 PyThreadState* __tstate = wxPyBeginAllowThreads();
41597 result = (PyObject *)wxGBPosition_Get(arg1);
41598
41599 wxPyEndAllowThreads(__tstate);
41600 if (PyErr_Occurred()) SWIG_fail;
41601 }
41602 resultobj = result;
41603 return resultobj;
41604 fail:
41605 return NULL;
41606 }
41607
41608
41609 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41610 PyObject *obj;
41611 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41612 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41613 Py_INCREF(obj);
41614 return Py_BuildValue((char *)"");
41615 }
41616 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41617 PyObject *resultobj;
41618 int arg1 = (int) 1 ;
41619 int arg2 = (int) 1 ;
41620 wxGBSpan *result;
41621 PyObject * obj0 = 0 ;
41622 PyObject * obj1 = 0 ;
41623 char *kwnames[] = {
41624 (char *) "rowspan",(char *) "colspan", NULL
41625 };
41626
41627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41628 if (obj0) {
41629 {
41630 arg1 = (int)(SWIG_As_int(obj0));
41631 if (SWIG_arg_fail(1)) SWIG_fail;
41632 }
41633 }
41634 if (obj1) {
41635 {
41636 arg2 = (int)(SWIG_As_int(obj1));
41637 if (SWIG_arg_fail(2)) SWIG_fail;
41638 }
41639 }
41640 {
41641 PyThreadState* __tstate = wxPyBeginAllowThreads();
41642 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41643
41644 wxPyEndAllowThreads(__tstate);
41645 if (PyErr_Occurred()) SWIG_fail;
41646 }
41647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41648 return resultobj;
41649 fail:
41650 return NULL;
41651 }
41652
41653
41654 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41655 PyObject *resultobj;
41656 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41657 int result;
41658 PyObject * obj0 = 0 ;
41659 char *kwnames[] = {
41660 (char *) "self", NULL
41661 };
41662
41663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41665 if (SWIG_arg_fail(1)) SWIG_fail;
41666 {
41667 PyThreadState* __tstate = wxPyBeginAllowThreads();
41668 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41669
41670 wxPyEndAllowThreads(__tstate);
41671 if (PyErr_Occurred()) SWIG_fail;
41672 }
41673 {
41674 resultobj = SWIG_From_int((int)(result));
41675 }
41676 return resultobj;
41677 fail:
41678 return NULL;
41679 }
41680
41681
41682 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41683 PyObject *resultobj;
41684 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41685 int result;
41686 PyObject * obj0 = 0 ;
41687 char *kwnames[] = {
41688 (char *) "self", NULL
41689 };
41690
41691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41693 if (SWIG_arg_fail(1)) SWIG_fail;
41694 {
41695 PyThreadState* __tstate = wxPyBeginAllowThreads();
41696 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41697
41698 wxPyEndAllowThreads(__tstate);
41699 if (PyErr_Occurred()) SWIG_fail;
41700 }
41701 {
41702 resultobj = SWIG_From_int((int)(result));
41703 }
41704 return resultobj;
41705 fail:
41706 return NULL;
41707 }
41708
41709
41710 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41711 PyObject *resultobj;
41712 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41713 int arg2 ;
41714 PyObject * obj0 = 0 ;
41715 PyObject * obj1 = 0 ;
41716 char *kwnames[] = {
41717 (char *) "self",(char *) "rowspan", NULL
41718 };
41719
41720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41722 if (SWIG_arg_fail(1)) SWIG_fail;
41723 {
41724 arg2 = (int)(SWIG_As_int(obj1));
41725 if (SWIG_arg_fail(2)) SWIG_fail;
41726 }
41727 {
41728 PyThreadState* __tstate = wxPyBeginAllowThreads();
41729 (arg1)->SetRowspan(arg2);
41730
41731 wxPyEndAllowThreads(__tstate);
41732 if (PyErr_Occurred()) SWIG_fail;
41733 }
41734 Py_INCREF(Py_None); resultobj = Py_None;
41735 return resultobj;
41736 fail:
41737 return NULL;
41738 }
41739
41740
41741 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj;
41743 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41744 int arg2 ;
41745 PyObject * obj0 = 0 ;
41746 PyObject * obj1 = 0 ;
41747 char *kwnames[] = {
41748 (char *) "self",(char *) "colspan", NULL
41749 };
41750
41751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41753 if (SWIG_arg_fail(1)) SWIG_fail;
41754 {
41755 arg2 = (int)(SWIG_As_int(obj1));
41756 if (SWIG_arg_fail(2)) SWIG_fail;
41757 }
41758 {
41759 PyThreadState* __tstate = wxPyBeginAllowThreads();
41760 (arg1)->SetColspan(arg2);
41761
41762 wxPyEndAllowThreads(__tstate);
41763 if (PyErr_Occurred()) SWIG_fail;
41764 }
41765 Py_INCREF(Py_None); resultobj = Py_None;
41766 return resultobj;
41767 fail:
41768 return NULL;
41769 }
41770
41771
41772 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41773 PyObject *resultobj;
41774 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41775 wxGBSpan *arg2 = 0 ;
41776 bool result;
41777 wxGBSpan temp2 ;
41778 PyObject * obj0 = 0 ;
41779 PyObject * obj1 = 0 ;
41780 char *kwnames[] = {
41781 (char *) "self",(char *) "other", NULL
41782 };
41783
41784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41786 if (SWIG_arg_fail(1)) SWIG_fail;
41787 {
41788 arg2 = &temp2;
41789 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41790 }
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41794
41795 wxPyEndAllowThreads(__tstate);
41796 if (PyErr_Occurred()) SWIG_fail;
41797 }
41798 {
41799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41800 }
41801 return resultobj;
41802 fail:
41803 return NULL;
41804 }
41805
41806
41807 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41808 PyObject *resultobj;
41809 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41810 wxGBSpan *arg2 = 0 ;
41811 bool result;
41812 wxGBSpan temp2 ;
41813 PyObject * obj0 = 0 ;
41814 PyObject * obj1 = 0 ;
41815 char *kwnames[] = {
41816 (char *) "self",(char *) "other", NULL
41817 };
41818
41819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41821 if (SWIG_arg_fail(1)) SWIG_fail;
41822 {
41823 arg2 = &temp2;
41824 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41825 }
41826 {
41827 PyThreadState* __tstate = wxPyBeginAllowThreads();
41828 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41829
41830 wxPyEndAllowThreads(__tstate);
41831 if (PyErr_Occurred()) SWIG_fail;
41832 }
41833 {
41834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41835 }
41836 return resultobj;
41837 fail:
41838 return NULL;
41839 }
41840
41841
41842 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41843 PyObject *resultobj;
41844 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41845 int arg2 = (int) 1 ;
41846 int arg3 = (int) 1 ;
41847 PyObject * obj0 = 0 ;
41848 PyObject * obj1 = 0 ;
41849 PyObject * obj2 = 0 ;
41850 char *kwnames[] = {
41851 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41852 };
41853
41854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41856 if (SWIG_arg_fail(1)) SWIG_fail;
41857 if (obj1) {
41858 {
41859 arg2 = (int)(SWIG_As_int(obj1));
41860 if (SWIG_arg_fail(2)) SWIG_fail;
41861 }
41862 }
41863 if (obj2) {
41864 {
41865 arg3 = (int)(SWIG_As_int(obj2));
41866 if (SWIG_arg_fail(3)) SWIG_fail;
41867 }
41868 }
41869 {
41870 PyThreadState* __tstate = wxPyBeginAllowThreads();
41871 wxGBSpan_Set(arg1,arg2,arg3);
41872
41873 wxPyEndAllowThreads(__tstate);
41874 if (PyErr_Occurred()) SWIG_fail;
41875 }
41876 Py_INCREF(Py_None); resultobj = Py_None;
41877 return resultobj;
41878 fail:
41879 return NULL;
41880 }
41881
41882
41883 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41884 PyObject *resultobj;
41885 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41886 PyObject *result;
41887 PyObject * obj0 = 0 ;
41888 char *kwnames[] = {
41889 (char *) "self", NULL
41890 };
41891
41892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41894 if (SWIG_arg_fail(1)) SWIG_fail;
41895 {
41896 PyThreadState* __tstate = wxPyBeginAllowThreads();
41897 result = (PyObject *)wxGBSpan_Get(arg1);
41898
41899 wxPyEndAllowThreads(__tstate);
41900 if (PyErr_Occurred()) SWIG_fail;
41901 }
41902 resultobj = result;
41903 return resultobj;
41904 fail:
41905 return NULL;
41906 }
41907
41908
41909 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41910 PyObject *obj;
41911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41912 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41913 Py_INCREF(obj);
41914 return Py_BuildValue((char *)"");
41915 }
41916 static int _wrap_DefaultSpan_set(PyObject *) {
41917 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41918 return 1;
41919 }
41920
41921
41922 static PyObject *_wrap_DefaultSpan_get(void) {
41923 PyObject *pyobj;
41924
41925 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41926 return pyobj;
41927 }
41928
41929
41930 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41931 PyObject *resultobj;
41932 wxGBSizerItem *result;
41933 char *kwnames[] = {
41934 NULL
41935 };
41936
41937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41938 {
41939 PyThreadState* __tstate = wxPyBeginAllowThreads();
41940 result = (wxGBSizerItem *)new wxGBSizerItem();
41941
41942 wxPyEndAllowThreads(__tstate);
41943 if (PyErr_Occurred()) SWIG_fail;
41944 }
41945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41946 return resultobj;
41947 fail:
41948 return NULL;
41949 }
41950
41951
41952 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41953 PyObject *resultobj;
41954 wxWindow *arg1 = (wxWindow *) 0 ;
41955 wxGBPosition *arg2 = 0 ;
41956 wxGBSpan *arg3 = 0 ;
41957 int arg4 ;
41958 int arg5 ;
41959 PyObject *arg6 = (PyObject *) NULL ;
41960 wxGBSizerItem *result;
41961 wxGBPosition temp2 ;
41962 wxGBSpan temp3 ;
41963 PyObject * obj0 = 0 ;
41964 PyObject * obj1 = 0 ;
41965 PyObject * obj2 = 0 ;
41966 PyObject * obj3 = 0 ;
41967 PyObject * obj4 = 0 ;
41968 PyObject * obj5 = 0 ;
41969 char *kwnames[] = {
41970 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41971 };
41972
41973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41975 if (SWIG_arg_fail(1)) SWIG_fail;
41976 {
41977 arg2 = &temp2;
41978 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41979 }
41980 {
41981 arg3 = &temp3;
41982 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41983 }
41984 {
41985 arg4 = (int)(SWIG_As_int(obj3));
41986 if (SWIG_arg_fail(4)) SWIG_fail;
41987 }
41988 {
41989 arg5 = (int)(SWIG_As_int(obj4));
41990 if (SWIG_arg_fail(5)) SWIG_fail;
41991 }
41992 if (obj5) {
41993 arg6 = obj5;
41994 }
41995 {
41996 PyThreadState* __tstate = wxPyBeginAllowThreads();
41997 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41998
41999 wxPyEndAllowThreads(__tstate);
42000 if (PyErr_Occurred()) SWIG_fail;
42001 }
42002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42003 return resultobj;
42004 fail:
42005 return NULL;
42006 }
42007
42008
42009 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42010 PyObject *resultobj;
42011 wxSizer *arg1 = (wxSizer *) 0 ;
42012 wxGBPosition *arg2 = 0 ;
42013 wxGBSpan *arg3 = 0 ;
42014 int arg4 ;
42015 int arg5 ;
42016 PyObject *arg6 = (PyObject *) NULL ;
42017 wxGBSizerItem *result;
42018 wxGBPosition temp2 ;
42019 wxGBSpan temp3 ;
42020 PyObject * obj0 = 0 ;
42021 PyObject * obj1 = 0 ;
42022 PyObject * obj2 = 0 ;
42023 PyObject * obj3 = 0 ;
42024 PyObject * obj4 = 0 ;
42025 PyObject * obj5 = 0 ;
42026 char *kwnames[] = {
42027 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42028 };
42029
42030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42032 if (SWIG_arg_fail(1)) SWIG_fail;
42033 {
42034 arg2 = &temp2;
42035 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42036 }
42037 {
42038 arg3 = &temp3;
42039 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42040 }
42041 {
42042 arg4 = (int)(SWIG_As_int(obj3));
42043 if (SWIG_arg_fail(4)) SWIG_fail;
42044 }
42045 {
42046 arg5 = (int)(SWIG_As_int(obj4));
42047 if (SWIG_arg_fail(5)) SWIG_fail;
42048 }
42049 if (obj5) {
42050 arg6 = obj5;
42051 }
42052 {
42053 PyThreadState* __tstate = wxPyBeginAllowThreads();
42054 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42055
42056 wxPyEndAllowThreads(__tstate);
42057 if (PyErr_Occurred()) SWIG_fail;
42058 }
42059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42060 return resultobj;
42061 fail:
42062 return NULL;
42063 }
42064
42065
42066 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42067 PyObject *resultobj;
42068 int arg1 ;
42069 int arg2 ;
42070 wxGBPosition *arg3 = 0 ;
42071 wxGBSpan *arg4 = 0 ;
42072 int arg5 ;
42073 int arg6 ;
42074 PyObject *arg7 = (PyObject *) NULL ;
42075 wxGBSizerItem *result;
42076 wxGBPosition temp3 ;
42077 wxGBSpan temp4 ;
42078 PyObject * obj0 = 0 ;
42079 PyObject * obj1 = 0 ;
42080 PyObject * obj2 = 0 ;
42081 PyObject * obj3 = 0 ;
42082 PyObject * obj4 = 0 ;
42083 PyObject * obj5 = 0 ;
42084 PyObject * obj6 = 0 ;
42085 char *kwnames[] = {
42086 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42087 };
42088
42089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42090 {
42091 arg1 = (int)(SWIG_As_int(obj0));
42092 if (SWIG_arg_fail(1)) SWIG_fail;
42093 }
42094 {
42095 arg2 = (int)(SWIG_As_int(obj1));
42096 if (SWIG_arg_fail(2)) SWIG_fail;
42097 }
42098 {
42099 arg3 = &temp3;
42100 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42101 }
42102 {
42103 arg4 = &temp4;
42104 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42105 }
42106 {
42107 arg5 = (int)(SWIG_As_int(obj4));
42108 if (SWIG_arg_fail(5)) SWIG_fail;
42109 }
42110 {
42111 arg6 = (int)(SWIG_As_int(obj5));
42112 if (SWIG_arg_fail(6)) SWIG_fail;
42113 }
42114 if (obj6) {
42115 arg7 = obj6;
42116 }
42117 {
42118 PyThreadState* __tstate = wxPyBeginAllowThreads();
42119 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42120
42121 wxPyEndAllowThreads(__tstate);
42122 if (PyErr_Occurred()) SWIG_fail;
42123 }
42124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42125 return resultobj;
42126 fail:
42127 return NULL;
42128 }
42129
42130
42131 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42132 PyObject *resultobj;
42133 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42134 wxGBPosition result;
42135 PyObject * obj0 = 0 ;
42136 char *kwnames[] = {
42137 (char *) "self", NULL
42138 };
42139
42140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42142 if (SWIG_arg_fail(1)) SWIG_fail;
42143 {
42144 PyThreadState* __tstate = wxPyBeginAllowThreads();
42145 result = ((wxGBSizerItem const *)arg1)->GetPos();
42146
42147 wxPyEndAllowThreads(__tstate);
42148 if (PyErr_Occurred()) SWIG_fail;
42149 }
42150 {
42151 wxGBPosition * resultptr;
42152 resultptr = new wxGBPosition((wxGBPosition &)(result));
42153 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42154 }
42155 return resultobj;
42156 fail:
42157 return NULL;
42158 }
42159
42160
42161 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42162 PyObject *resultobj;
42163 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42164 wxGBSpan result;
42165 PyObject * obj0 = 0 ;
42166 char *kwnames[] = {
42167 (char *) "self", NULL
42168 };
42169
42170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42172 if (SWIG_arg_fail(1)) SWIG_fail;
42173 {
42174 PyThreadState* __tstate = wxPyBeginAllowThreads();
42175 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42176
42177 wxPyEndAllowThreads(__tstate);
42178 if (PyErr_Occurred()) SWIG_fail;
42179 }
42180 {
42181 wxGBSpan * resultptr;
42182 resultptr = new wxGBSpan((wxGBSpan &)(result));
42183 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42184 }
42185 return resultobj;
42186 fail:
42187 return NULL;
42188 }
42189
42190
42191 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42192 PyObject *resultobj;
42193 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42194 wxGBPosition *arg2 = 0 ;
42195 bool result;
42196 wxGBPosition temp2 ;
42197 PyObject * obj0 = 0 ;
42198 PyObject * obj1 = 0 ;
42199 char *kwnames[] = {
42200 (char *) "self",(char *) "pos", NULL
42201 };
42202
42203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42205 if (SWIG_arg_fail(1)) SWIG_fail;
42206 {
42207 arg2 = &temp2;
42208 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42209 }
42210 {
42211 PyThreadState* __tstate = wxPyBeginAllowThreads();
42212 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42213
42214 wxPyEndAllowThreads(__tstate);
42215 if (PyErr_Occurred()) SWIG_fail;
42216 }
42217 {
42218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42219 }
42220 return resultobj;
42221 fail:
42222 return NULL;
42223 }
42224
42225
42226 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42227 PyObject *resultobj;
42228 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42229 wxGBSpan *arg2 = 0 ;
42230 bool result;
42231 wxGBSpan temp2 ;
42232 PyObject * obj0 = 0 ;
42233 PyObject * obj1 = 0 ;
42234 char *kwnames[] = {
42235 (char *) "self",(char *) "span", NULL
42236 };
42237
42238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42240 if (SWIG_arg_fail(1)) SWIG_fail;
42241 {
42242 arg2 = &temp2;
42243 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42244 }
42245 {
42246 PyThreadState* __tstate = wxPyBeginAllowThreads();
42247 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42248
42249 wxPyEndAllowThreads(__tstate);
42250 if (PyErr_Occurred()) SWIG_fail;
42251 }
42252 {
42253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42254 }
42255 return resultobj;
42256 fail:
42257 return NULL;
42258 }
42259
42260
42261 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42262 PyObject *resultobj;
42263 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42264 wxGBSizerItem *arg2 = 0 ;
42265 bool result;
42266 PyObject * obj0 = 0 ;
42267 PyObject * obj1 = 0 ;
42268 char *kwnames[] = {
42269 (char *) "self",(char *) "other", NULL
42270 };
42271
42272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42274 if (SWIG_arg_fail(1)) SWIG_fail;
42275 {
42276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42277 if (SWIG_arg_fail(2)) SWIG_fail;
42278 if (arg2 == NULL) {
42279 SWIG_null_ref("wxGBSizerItem");
42280 }
42281 if (SWIG_arg_fail(2)) SWIG_fail;
42282 }
42283 {
42284 PyThreadState* __tstate = wxPyBeginAllowThreads();
42285 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42286
42287 wxPyEndAllowThreads(__tstate);
42288 if (PyErr_Occurred()) SWIG_fail;
42289 }
42290 {
42291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42292 }
42293 return resultobj;
42294 fail:
42295 return NULL;
42296 }
42297
42298
42299 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42300 PyObject *resultobj;
42301 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42302 wxGBPosition *arg2 = 0 ;
42303 wxGBSpan *arg3 = 0 ;
42304 bool result;
42305 wxGBPosition temp2 ;
42306 wxGBSpan temp3 ;
42307 PyObject * obj0 = 0 ;
42308 PyObject * obj1 = 0 ;
42309 PyObject * obj2 = 0 ;
42310 char *kwnames[] = {
42311 (char *) "self",(char *) "pos",(char *) "span", NULL
42312 };
42313
42314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42316 if (SWIG_arg_fail(1)) SWIG_fail;
42317 {
42318 arg2 = &temp2;
42319 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42320 }
42321 {
42322 arg3 = &temp3;
42323 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42324 }
42325 {
42326 PyThreadState* __tstate = wxPyBeginAllowThreads();
42327 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42328
42329 wxPyEndAllowThreads(__tstate);
42330 if (PyErr_Occurred()) SWIG_fail;
42331 }
42332 {
42333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42334 }
42335 return resultobj;
42336 fail:
42337 return NULL;
42338 }
42339
42340
42341 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42342 PyObject *resultobj;
42343 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42344 wxGBPosition result;
42345 PyObject * obj0 = 0 ;
42346 char *kwnames[] = {
42347 (char *) "self", NULL
42348 };
42349
42350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42352 if (SWIG_arg_fail(1)) SWIG_fail;
42353 {
42354 PyThreadState* __tstate = wxPyBeginAllowThreads();
42355 result = wxGBSizerItem_GetEndPos(arg1);
42356
42357 wxPyEndAllowThreads(__tstate);
42358 if (PyErr_Occurred()) SWIG_fail;
42359 }
42360 {
42361 wxGBPosition * resultptr;
42362 resultptr = new wxGBPosition((wxGBPosition &)(result));
42363 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42364 }
42365 return resultobj;
42366 fail:
42367 return NULL;
42368 }
42369
42370
42371 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42372 PyObject *resultobj;
42373 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42374 wxGridBagSizer *result;
42375 PyObject * obj0 = 0 ;
42376 char *kwnames[] = {
42377 (char *) "self", NULL
42378 };
42379
42380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42382 if (SWIG_arg_fail(1)) SWIG_fail;
42383 {
42384 PyThreadState* __tstate = wxPyBeginAllowThreads();
42385 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42386
42387 wxPyEndAllowThreads(__tstate);
42388 if (PyErr_Occurred()) SWIG_fail;
42389 }
42390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42391 return resultobj;
42392 fail:
42393 return NULL;
42394 }
42395
42396
42397 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42398 PyObject *resultobj;
42399 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42400 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42401 PyObject * obj0 = 0 ;
42402 PyObject * obj1 = 0 ;
42403 char *kwnames[] = {
42404 (char *) "self",(char *) "sizer", NULL
42405 };
42406
42407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42409 if (SWIG_arg_fail(1)) SWIG_fail;
42410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42411 if (SWIG_arg_fail(2)) SWIG_fail;
42412 {
42413 PyThreadState* __tstate = wxPyBeginAllowThreads();
42414 (arg1)->SetGBSizer(arg2);
42415
42416 wxPyEndAllowThreads(__tstate);
42417 if (PyErr_Occurred()) SWIG_fail;
42418 }
42419 Py_INCREF(Py_None); resultobj = Py_None;
42420 return resultobj;
42421 fail:
42422 return NULL;
42423 }
42424
42425
42426 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42427 PyObject *obj;
42428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42429 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42430 Py_INCREF(obj);
42431 return Py_BuildValue((char *)"");
42432 }
42433 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42434 PyObject *resultobj;
42435 int arg1 = (int) 0 ;
42436 int arg2 = (int) 0 ;
42437 wxGridBagSizer *result;
42438 PyObject * obj0 = 0 ;
42439 PyObject * obj1 = 0 ;
42440 char *kwnames[] = {
42441 (char *) "vgap",(char *) "hgap", NULL
42442 };
42443
42444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42445 if (obj0) {
42446 {
42447 arg1 = (int)(SWIG_As_int(obj0));
42448 if (SWIG_arg_fail(1)) SWIG_fail;
42449 }
42450 }
42451 if (obj1) {
42452 {
42453 arg2 = (int)(SWIG_As_int(obj1));
42454 if (SWIG_arg_fail(2)) SWIG_fail;
42455 }
42456 }
42457 {
42458 PyThreadState* __tstate = wxPyBeginAllowThreads();
42459 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42460
42461 wxPyEndAllowThreads(__tstate);
42462 if (PyErr_Occurred()) SWIG_fail;
42463 }
42464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42465 return resultobj;
42466 fail:
42467 return NULL;
42468 }
42469
42470
42471 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42472 PyObject *resultobj;
42473 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42474 PyObject *arg2 = (PyObject *) 0 ;
42475 wxGBPosition *arg3 = 0 ;
42476 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42477 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42478 int arg5 = (int) 0 ;
42479 int arg6 = (int) 0 ;
42480 PyObject *arg7 = (PyObject *) NULL ;
42481 wxGBSizerItem *result;
42482 wxGBPosition temp3 ;
42483 wxGBSpan temp4 ;
42484 PyObject * obj0 = 0 ;
42485 PyObject * obj1 = 0 ;
42486 PyObject * obj2 = 0 ;
42487 PyObject * obj3 = 0 ;
42488 PyObject * obj4 = 0 ;
42489 PyObject * obj5 = 0 ;
42490 PyObject * obj6 = 0 ;
42491 char *kwnames[] = {
42492 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42493 };
42494
42495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42497 if (SWIG_arg_fail(1)) SWIG_fail;
42498 arg2 = obj1;
42499 {
42500 arg3 = &temp3;
42501 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42502 }
42503 if (obj3) {
42504 {
42505 arg4 = &temp4;
42506 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42507 }
42508 }
42509 if (obj4) {
42510 {
42511 arg5 = (int)(SWIG_As_int(obj4));
42512 if (SWIG_arg_fail(5)) SWIG_fail;
42513 }
42514 }
42515 if (obj5) {
42516 {
42517 arg6 = (int)(SWIG_As_int(obj5));
42518 if (SWIG_arg_fail(6)) SWIG_fail;
42519 }
42520 }
42521 if (obj6) {
42522 arg7 = obj6;
42523 }
42524 {
42525 PyThreadState* __tstate = wxPyBeginAllowThreads();
42526 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42527
42528 wxPyEndAllowThreads(__tstate);
42529 if (PyErr_Occurred()) SWIG_fail;
42530 }
42531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42532 return resultobj;
42533 fail:
42534 return NULL;
42535 }
42536
42537
42538 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42539 PyObject *resultobj;
42540 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42541 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42542 wxGBSizerItem *result;
42543 PyObject * obj0 = 0 ;
42544 PyObject * obj1 = 0 ;
42545 char *kwnames[] = {
42546 (char *) "self",(char *) "item", NULL
42547 };
42548
42549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42551 if (SWIG_arg_fail(1)) SWIG_fail;
42552 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42553 if (SWIG_arg_fail(2)) SWIG_fail;
42554 {
42555 PyThreadState* __tstate = wxPyBeginAllowThreads();
42556 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42557
42558 wxPyEndAllowThreads(__tstate);
42559 if (PyErr_Occurred()) SWIG_fail;
42560 }
42561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42562 return resultobj;
42563 fail:
42564 return NULL;
42565 }
42566
42567
42568 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42569 PyObject *resultobj;
42570 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42571 int arg2 ;
42572 int arg3 ;
42573 wxSize result;
42574 PyObject * obj0 = 0 ;
42575 PyObject * obj1 = 0 ;
42576 PyObject * obj2 = 0 ;
42577 char *kwnames[] = {
42578 (char *) "self",(char *) "row",(char *) "col", NULL
42579 };
42580
42581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42583 if (SWIG_arg_fail(1)) SWIG_fail;
42584 {
42585 arg2 = (int)(SWIG_As_int(obj1));
42586 if (SWIG_arg_fail(2)) SWIG_fail;
42587 }
42588 {
42589 arg3 = (int)(SWIG_As_int(obj2));
42590 if (SWIG_arg_fail(3)) SWIG_fail;
42591 }
42592 {
42593 PyThreadState* __tstate = wxPyBeginAllowThreads();
42594 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42595
42596 wxPyEndAllowThreads(__tstate);
42597 if (PyErr_Occurred()) SWIG_fail;
42598 }
42599 {
42600 wxSize * resultptr;
42601 resultptr = new wxSize((wxSize &)(result));
42602 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42603 }
42604 return resultobj;
42605 fail:
42606 return NULL;
42607 }
42608
42609
42610 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42611 PyObject *resultobj;
42612 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42613 wxSize result;
42614 PyObject * obj0 = 0 ;
42615 char *kwnames[] = {
42616 (char *) "self", NULL
42617 };
42618
42619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42621 if (SWIG_arg_fail(1)) SWIG_fail;
42622 {
42623 PyThreadState* __tstate = wxPyBeginAllowThreads();
42624 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42625
42626 wxPyEndAllowThreads(__tstate);
42627 if (PyErr_Occurred()) SWIG_fail;
42628 }
42629 {
42630 wxSize * resultptr;
42631 resultptr = new wxSize((wxSize &)(result));
42632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42633 }
42634 return resultobj;
42635 fail:
42636 return NULL;
42637 }
42638
42639
42640 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42641 PyObject *resultobj;
42642 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42643 wxSize *arg2 = 0 ;
42644 wxSize temp2 ;
42645 PyObject * obj0 = 0 ;
42646 PyObject * obj1 = 0 ;
42647 char *kwnames[] = {
42648 (char *) "self",(char *) "sz", NULL
42649 };
42650
42651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42653 if (SWIG_arg_fail(1)) SWIG_fail;
42654 {
42655 arg2 = &temp2;
42656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42657 }
42658 {
42659 PyThreadState* __tstate = wxPyBeginAllowThreads();
42660 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42661
42662 wxPyEndAllowThreads(__tstate);
42663 if (PyErr_Occurred()) SWIG_fail;
42664 }
42665 Py_INCREF(Py_None); resultobj = Py_None;
42666 return resultobj;
42667 fail:
42668 return NULL;
42669 }
42670
42671
42672 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42673 PyObject *resultobj;
42674 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42675 wxWindow *arg2 = (wxWindow *) 0 ;
42676 wxGBPosition result;
42677 PyObject * obj0 = 0 ;
42678 PyObject * obj1 = 0 ;
42679
42680 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42682 if (SWIG_arg_fail(1)) SWIG_fail;
42683 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42684 if (SWIG_arg_fail(2)) SWIG_fail;
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 result = (arg1)->GetItemPosition(arg2);
42688
42689 wxPyEndAllowThreads(__tstate);
42690 if (PyErr_Occurred()) SWIG_fail;
42691 }
42692 {
42693 wxGBPosition * resultptr;
42694 resultptr = new wxGBPosition((wxGBPosition &)(result));
42695 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42696 }
42697 return resultobj;
42698 fail:
42699 return NULL;
42700 }
42701
42702
42703 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42704 PyObject *resultobj;
42705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42706 wxSizer *arg2 = (wxSizer *) 0 ;
42707 wxGBPosition result;
42708 PyObject * obj0 = 0 ;
42709 PyObject * obj1 = 0 ;
42710
42711 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42713 if (SWIG_arg_fail(1)) SWIG_fail;
42714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42715 if (SWIG_arg_fail(2)) SWIG_fail;
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 result = (arg1)->GetItemPosition(arg2);
42719
42720 wxPyEndAllowThreads(__tstate);
42721 if (PyErr_Occurred()) SWIG_fail;
42722 }
42723 {
42724 wxGBPosition * resultptr;
42725 resultptr = new wxGBPosition((wxGBPosition &)(result));
42726 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42727 }
42728 return resultobj;
42729 fail:
42730 return NULL;
42731 }
42732
42733
42734 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42735 PyObject *resultobj;
42736 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42737 size_t arg2 ;
42738 wxGBPosition result;
42739 PyObject * obj0 = 0 ;
42740 PyObject * obj1 = 0 ;
42741
42742 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42744 if (SWIG_arg_fail(1)) SWIG_fail;
42745 {
42746 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42747 if (SWIG_arg_fail(2)) SWIG_fail;
42748 }
42749 {
42750 PyThreadState* __tstate = wxPyBeginAllowThreads();
42751 result = (arg1)->GetItemPosition(arg2);
42752
42753 wxPyEndAllowThreads(__tstate);
42754 if (PyErr_Occurred()) SWIG_fail;
42755 }
42756 {
42757 wxGBPosition * resultptr;
42758 resultptr = new wxGBPosition((wxGBPosition &)(result));
42759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42760 }
42761 return resultobj;
42762 fail:
42763 return NULL;
42764 }
42765
42766
42767 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42768 int argc;
42769 PyObject *argv[3];
42770 int ii;
42771
42772 argc = PyObject_Length(args);
42773 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42774 argv[ii] = PyTuple_GetItem(args,ii);
42775 }
42776 if (argc == 2) {
42777 int _v;
42778 {
42779 void *ptr;
42780 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42781 _v = 0;
42782 PyErr_Clear();
42783 } else {
42784 _v = 1;
42785 }
42786 }
42787 if (_v) {
42788 {
42789 void *ptr;
42790 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42791 _v = 0;
42792 PyErr_Clear();
42793 } else {
42794 _v = 1;
42795 }
42796 }
42797 if (_v) {
42798 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42799 }
42800 }
42801 }
42802 if (argc == 2) {
42803 int _v;
42804 {
42805 void *ptr;
42806 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42807 _v = 0;
42808 PyErr_Clear();
42809 } else {
42810 _v = 1;
42811 }
42812 }
42813 if (_v) {
42814 {
42815 void *ptr;
42816 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42817 _v = 0;
42818 PyErr_Clear();
42819 } else {
42820 _v = 1;
42821 }
42822 }
42823 if (_v) {
42824 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42825 }
42826 }
42827 }
42828 if (argc == 2) {
42829 int _v;
42830 {
42831 void *ptr;
42832 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42833 _v = 0;
42834 PyErr_Clear();
42835 } else {
42836 _v = 1;
42837 }
42838 }
42839 if (_v) {
42840 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42841 if (_v) {
42842 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42843 }
42844 }
42845 }
42846
42847 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42848 return NULL;
42849 }
42850
42851
42852 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42853 PyObject *resultobj;
42854 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42855 wxWindow *arg2 = (wxWindow *) 0 ;
42856 wxGBPosition *arg3 = 0 ;
42857 bool result;
42858 wxGBPosition temp3 ;
42859 PyObject * obj0 = 0 ;
42860 PyObject * obj1 = 0 ;
42861 PyObject * obj2 = 0 ;
42862
42863 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42865 if (SWIG_arg_fail(1)) SWIG_fail;
42866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42867 if (SWIG_arg_fail(2)) SWIG_fail;
42868 {
42869 arg3 = &temp3;
42870 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42871 }
42872 {
42873 PyThreadState* __tstate = wxPyBeginAllowThreads();
42874 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42875
42876 wxPyEndAllowThreads(__tstate);
42877 if (PyErr_Occurred()) SWIG_fail;
42878 }
42879 {
42880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42881 }
42882 return resultobj;
42883 fail:
42884 return NULL;
42885 }
42886
42887
42888 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42889 PyObject *resultobj;
42890 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42891 wxSizer *arg2 = (wxSizer *) 0 ;
42892 wxGBPosition *arg3 = 0 ;
42893 bool result;
42894 wxGBPosition temp3 ;
42895 PyObject * obj0 = 0 ;
42896 PyObject * obj1 = 0 ;
42897 PyObject * obj2 = 0 ;
42898
42899 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42901 if (SWIG_arg_fail(1)) SWIG_fail;
42902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42903 if (SWIG_arg_fail(2)) SWIG_fail;
42904 {
42905 arg3 = &temp3;
42906 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42907 }
42908 {
42909 PyThreadState* __tstate = wxPyBeginAllowThreads();
42910 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42911
42912 wxPyEndAllowThreads(__tstate);
42913 if (PyErr_Occurred()) SWIG_fail;
42914 }
42915 {
42916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42917 }
42918 return resultobj;
42919 fail:
42920 return NULL;
42921 }
42922
42923
42924 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42925 PyObject *resultobj;
42926 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42927 size_t arg2 ;
42928 wxGBPosition *arg3 = 0 ;
42929 bool result;
42930 wxGBPosition temp3 ;
42931 PyObject * obj0 = 0 ;
42932 PyObject * obj1 = 0 ;
42933 PyObject * obj2 = 0 ;
42934
42935 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42937 if (SWIG_arg_fail(1)) SWIG_fail;
42938 {
42939 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42940 if (SWIG_arg_fail(2)) SWIG_fail;
42941 }
42942 {
42943 arg3 = &temp3;
42944 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42945 }
42946 {
42947 PyThreadState* __tstate = wxPyBeginAllowThreads();
42948 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42949
42950 wxPyEndAllowThreads(__tstate);
42951 if (PyErr_Occurred()) SWIG_fail;
42952 }
42953 {
42954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42955 }
42956 return resultobj;
42957 fail:
42958 return NULL;
42959 }
42960
42961
42962 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42963 int argc;
42964 PyObject *argv[4];
42965 int ii;
42966
42967 argc = PyObject_Length(args);
42968 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42969 argv[ii] = PyTuple_GetItem(args,ii);
42970 }
42971 if (argc == 3) {
42972 int _v;
42973 {
42974 void *ptr;
42975 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42976 _v = 0;
42977 PyErr_Clear();
42978 } else {
42979 _v = 1;
42980 }
42981 }
42982 if (_v) {
42983 {
42984 void *ptr;
42985 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42986 _v = 0;
42987 PyErr_Clear();
42988 } else {
42989 _v = 1;
42990 }
42991 }
42992 if (_v) {
42993 {
42994 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42995 }
42996 if (_v) {
42997 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42998 }
42999 }
43000 }
43001 }
43002 if (argc == 3) {
43003 int _v;
43004 {
43005 void *ptr;
43006 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43007 _v = 0;
43008 PyErr_Clear();
43009 } else {
43010 _v = 1;
43011 }
43012 }
43013 if (_v) {
43014 {
43015 void *ptr;
43016 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43017 _v = 0;
43018 PyErr_Clear();
43019 } else {
43020 _v = 1;
43021 }
43022 }
43023 if (_v) {
43024 {
43025 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43026 }
43027 if (_v) {
43028 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43029 }
43030 }
43031 }
43032 }
43033 if (argc == 3) {
43034 int _v;
43035 {
43036 void *ptr;
43037 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43038 _v = 0;
43039 PyErr_Clear();
43040 } else {
43041 _v = 1;
43042 }
43043 }
43044 if (_v) {
43045 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43046 if (_v) {
43047 {
43048 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43049 }
43050 if (_v) {
43051 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43052 }
43053 }
43054 }
43055 }
43056
43057 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43058 return NULL;
43059 }
43060
43061
43062 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43063 PyObject *resultobj;
43064 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43065 wxWindow *arg2 = (wxWindow *) 0 ;
43066 wxGBSpan result;
43067 PyObject * obj0 = 0 ;
43068 PyObject * obj1 = 0 ;
43069
43070 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43072 if (SWIG_arg_fail(1)) SWIG_fail;
43073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43074 if (SWIG_arg_fail(2)) SWIG_fail;
43075 {
43076 PyThreadState* __tstate = wxPyBeginAllowThreads();
43077 result = (arg1)->GetItemSpan(arg2);
43078
43079 wxPyEndAllowThreads(__tstate);
43080 if (PyErr_Occurred()) SWIG_fail;
43081 }
43082 {
43083 wxGBSpan * resultptr;
43084 resultptr = new wxGBSpan((wxGBSpan &)(result));
43085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43086 }
43087 return resultobj;
43088 fail:
43089 return NULL;
43090 }
43091
43092
43093 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43094 PyObject *resultobj;
43095 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43096 wxSizer *arg2 = (wxSizer *) 0 ;
43097 wxGBSpan result;
43098 PyObject * obj0 = 0 ;
43099 PyObject * obj1 = 0 ;
43100
43101 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43103 if (SWIG_arg_fail(1)) SWIG_fail;
43104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43105 if (SWIG_arg_fail(2)) SWIG_fail;
43106 {
43107 PyThreadState* __tstate = wxPyBeginAllowThreads();
43108 result = (arg1)->GetItemSpan(arg2);
43109
43110 wxPyEndAllowThreads(__tstate);
43111 if (PyErr_Occurred()) SWIG_fail;
43112 }
43113 {
43114 wxGBSpan * resultptr;
43115 resultptr = new wxGBSpan((wxGBSpan &)(result));
43116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43117 }
43118 return resultobj;
43119 fail:
43120 return NULL;
43121 }
43122
43123
43124 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43125 PyObject *resultobj;
43126 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43127 size_t arg2 ;
43128 wxGBSpan result;
43129 PyObject * obj0 = 0 ;
43130 PyObject * obj1 = 0 ;
43131
43132 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43134 if (SWIG_arg_fail(1)) SWIG_fail;
43135 {
43136 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43137 if (SWIG_arg_fail(2)) SWIG_fail;
43138 }
43139 {
43140 PyThreadState* __tstate = wxPyBeginAllowThreads();
43141 result = (arg1)->GetItemSpan(arg2);
43142
43143 wxPyEndAllowThreads(__tstate);
43144 if (PyErr_Occurred()) SWIG_fail;
43145 }
43146 {
43147 wxGBSpan * resultptr;
43148 resultptr = new wxGBSpan((wxGBSpan &)(result));
43149 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43150 }
43151 return resultobj;
43152 fail:
43153 return NULL;
43154 }
43155
43156
43157 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43158 int argc;
43159 PyObject *argv[3];
43160 int ii;
43161
43162 argc = PyObject_Length(args);
43163 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43164 argv[ii] = PyTuple_GetItem(args,ii);
43165 }
43166 if (argc == 2) {
43167 int _v;
43168 {
43169 void *ptr;
43170 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43171 _v = 0;
43172 PyErr_Clear();
43173 } else {
43174 _v = 1;
43175 }
43176 }
43177 if (_v) {
43178 {
43179 void *ptr;
43180 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43181 _v = 0;
43182 PyErr_Clear();
43183 } else {
43184 _v = 1;
43185 }
43186 }
43187 if (_v) {
43188 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43189 }
43190 }
43191 }
43192 if (argc == 2) {
43193 int _v;
43194 {
43195 void *ptr;
43196 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43197 _v = 0;
43198 PyErr_Clear();
43199 } else {
43200 _v = 1;
43201 }
43202 }
43203 if (_v) {
43204 {
43205 void *ptr;
43206 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43207 _v = 0;
43208 PyErr_Clear();
43209 } else {
43210 _v = 1;
43211 }
43212 }
43213 if (_v) {
43214 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43215 }
43216 }
43217 }
43218 if (argc == 2) {
43219 int _v;
43220 {
43221 void *ptr;
43222 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43223 _v = 0;
43224 PyErr_Clear();
43225 } else {
43226 _v = 1;
43227 }
43228 }
43229 if (_v) {
43230 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43231 if (_v) {
43232 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43233 }
43234 }
43235 }
43236
43237 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43238 return NULL;
43239 }
43240
43241
43242 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43243 PyObject *resultobj;
43244 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43245 wxWindow *arg2 = (wxWindow *) 0 ;
43246 wxGBSpan *arg3 = 0 ;
43247 bool result;
43248 wxGBSpan temp3 ;
43249 PyObject * obj0 = 0 ;
43250 PyObject * obj1 = 0 ;
43251 PyObject * obj2 = 0 ;
43252
43253 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43255 if (SWIG_arg_fail(1)) SWIG_fail;
43256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43257 if (SWIG_arg_fail(2)) SWIG_fail;
43258 {
43259 arg3 = &temp3;
43260 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43261 }
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43265
43266 wxPyEndAllowThreads(__tstate);
43267 if (PyErr_Occurred()) SWIG_fail;
43268 }
43269 {
43270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43271 }
43272 return resultobj;
43273 fail:
43274 return NULL;
43275 }
43276
43277
43278 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43279 PyObject *resultobj;
43280 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43281 wxSizer *arg2 = (wxSizer *) 0 ;
43282 wxGBSpan *arg3 = 0 ;
43283 bool result;
43284 wxGBSpan temp3 ;
43285 PyObject * obj0 = 0 ;
43286 PyObject * obj1 = 0 ;
43287 PyObject * obj2 = 0 ;
43288
43289 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43291 if (SWIG_arg_fail(1)) SWIG_fail;
43292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43293 if (SWIG_arg_fail(2)) SWIG_fail;
43294 {
43295 arg3 = &temp3;
43296 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43297 }
43298 {
43299 PyThreadState* __tstate = wxPyBeginAllowThreads();
43300 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43301
43302 wxPyEndAllowThreads(__tstate);
43303 if (PyErr_Occurred()) SWIG_fail;
43304 }
43305 {
43306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43307 }
43308 return resultobj;
43309 fail:
43310 return NULL;
43311 }
43312
43313
43314 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43315 PyObject *resultobj;
43316 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43317 size_t arg2 ;
43318 wxGBSpan *arg3 = 0 ;
43319 bool result;
43320 wxGBSpan temp3 ;
43321 PyObject * obj0 = 0 ;
43322 PyObject * obj1 = 0 ;
43323 PyObject * obj2 = 0 ;
43324
43325 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43327 if (SWIG_arg_fail(1)) SWIG_fail;
43328 {
43329 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43330 if (SWIG_arg_fail(2)) SWIG_fail;
43331 }
43332 {
43333 arg3 = &temp3;
43334 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43335 }
43336 {
43337 PyThreadState* __tstate = wxPyBeginAllowThreads();
43338 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43339
43340 wxPyEndAllowThreads(__tstate);
43341 if (PyErr_Occurred()) SWIG_fail;
43342 }
43343 {
43344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43345 }
43346 return resultobj;
43347 fail:
43348 return NULL;
43349 }
43350
43351
43352 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43353 int argc;
43354 PyObject *argv[4];
43355 int ii;
43356
43357 argc = PyObject_Length(args);
43358 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43359 argv[ii] = PyTuple_GetItem(args,ii);
43360 }
43361 if (argc == 3) {
43362 int _v;
43363 {
43364 void *ptr;
43365 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43366 _v = 0;
43367 PyErr_Clear();
43368 } else {
43369 _v = 1;
43370 }
43371 }
43372 if (_v) {
43373 {
43374 void *ptr;
43375 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43376 _v = 0;
43377 PyErr_Clear();
43378 } else {
43379 _v = 1;
43380 }
43381 }
43382 if (_v) {
43383 {
43384 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43385 }
43386 if (_v) {
43387 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43388 }
43389 }
43390 }
43391 }
43392 if (argc == 3) {
43393 int _v;
43394 {
43395 void *ptr;
43396 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43397 _v = 0;
43398 PyErr_Clear();
43399 } else {
43400 _v = 1;
43401 }
43402 }
43403 if (_v) {
43404 {
43405 void *ptr;
43406 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43407 _v = 0;
43408 PyErr_Clear();
43409 } else {
43410 _v = 1;
43411 }
43412 }
43413 if (_v) {
43414 {
43415 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43416 }
43417 if (_v) {
43418 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43419 }
43420 }
43421 }
43422 }
43423 if (argc == 3) {
43424 int _v;
43425 {
43426 void *ptr;
43427 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43428 _v = 0;
43429 PyErr_Clear();
43430 } else {
43431 _v = 1;
43432 }
43433 }
43434 if (_v) {
43435 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43436 if (_v) {
43437 {
43438 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43439 }
43440 if (_v) {
43441 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43442 }
43443 }
43444 }
43445 }
43446
43447 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43448 return NULL;
43449 }
43450
43451
43452 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43453 PyObject *resultobj;
43454 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43455 wxWindow *arg2 = (wxWindow *) 0 ;
43456 wxGBSizerItem *result;
43457 PyObject * obj0 = 0 ;
43458 PyObject * obj1 = 0 ;
43459
43460 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43462 if (SWIG_arg_fail(1)) SWIG_fail;
43463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43464 if (SWIG_arg_fail(2)) SWIG_fail;
43465 {
43466 PyThreadState* __tstate = wxPyBeginAllowThreads();
43467 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43468
43469 wxPyEndAllowThreads(__tstate);
43470 if (PyErr_Occurred()) SWIG_fail;
43471 }
43472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43473 return resultobj;
43474 fail:
43475 return NULL;
43476 }
43477
43478
43479 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43480 PyObject *resultobj;
43481 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43482 wxSizer *arg2 = (wxSizer *) 0 ;
43483 wxGBSizerItem *result;
43484 PyObject * obj0 = 0 ;
43485 PyObject * obj1 = 0 ;
43486
43487 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43489 if (SWIG_arg_fail(1)) SWIG_fail;
43490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43491 if (SWIG_arg_fail(2)) SWIG_fail;
43492 {
43493 PyThreadState* __tstate = wxPyBeginAllowThreads();
43494 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43495
43496 wxPyEndAllowThreads(__tstate);
43497 if (PyErr_Occurred()) SWIG_fail;
43498 }
43499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43500 return resultobj;
43501 fail:
43502 return NULL;
43503 }
43504
43505
43506 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43507 int argc;
43508 PyObject *argv[3];
43509 int ii;
43510
43511 argc = PyObject_Length(args);
43512 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43513 argv[ii] = PyTuple_GetItem(args,ii);
43514 }
43515 if (argc == 2) {
43516 int _v;
43517 {
43518 void *ptr;
43519 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43520 _v = 0;
43521 PyErr_Clear();
43522 } else {
43523 _v = 1;
43524 }
43525 }
43526 if (_v) {
43527 {
43528 void *ptr;
43529 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43530 _v = 0;
43531 PyErr_Clear();
43532 } else {
43533 _v = 1;
43534 }
43535 }
43536 if (_v) {
43537 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43538 }
43539 }
43540 }
43541 if (argc == 2) {
43542 int _v;
43543 {
43544 void *ptr;
43545 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43546 _v = 0;
43547 PyErr_Clear();
43548 } else {
43549 _v = 1;
43550 }
43551 }
43552 if (_v) {
43553 {
43554 void *ptr;
43555 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43556 _v = 0;
43557 PyErr_Clear();
43558 } else {
43559 _v = 1;
43560 }
43561 }
43562 if (_v) {
43563 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43564 }
43565 }
43566 }
43567
43568 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43569 return NULL;
43570 }
43571
43572
43573 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43574 PyObject *resultobj;
43575 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43576 wxGBPosition *arg2 = 0 ;
43577 wxGBSizerItem *result;
43578 wxGBPosition temp2 ;
43579 PyObject * obj0 = 0 ;
43580 PyObject * obj1 = 0 ;
43581 char *kwnames[] = {
43582 (char *) "self",(char *) "pos", NULL
43583 };
43584
43585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43587 if (SWIG_arg_fail(1)) SWIG_fail;
43588 {
43589 arg2 = &temp2;
43590 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43591 }
43592 {
43593 PyThreadState* __tstate = wxPyBeginAllowThreads();
43594 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43595
43596 wxPyEndAllowThreads(__tstate);
43597 if (PyErr_Occurred()) SWIG_fail;
43598 }
43599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43600 return resultobj;
43601 fail:
43602 return NULL;
43603 }
43604
43605
43606 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43607 PyObject *resultobj;
43608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43609 wxPoint *arg2 = 0 ;
43610 wxGBSizerItem *result;
43611 wxPoint temp2 ;
43612 PyObject * obj0 = 0 ;
43613 PyObject * obj1 = 0 ;
43614 char *kwnames[] = {
43615 (char *) "self",(char *) "pt", NULL
43616 };
43617
43618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43620 if (SWIG_arg_fail(1)) SWIG_fail;
43621 {
43622 arg2 = &temp2;
43623 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43624 }
43625 {
43626 PyThreadState* __tstate = wxPyBeginAllowThreads();
43627 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43628
43629 wxPyEndAllowThreads(__tstate);
43630 if (PyErr_Occurred()) SWIG_fail;
43631 }
43632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43633 return resultobj;
43634 fail:
43635 return NULL;
43636 }
43637
43638
43639 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43640 PyObject *resultobj;
43641 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43642 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43643 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43644 bool result;
43645 PyObject * obj0 = 0 ;
43646 PyObject * obj1 = 0 ;
43647 PyObject * obj2 = 0 ;
43648 char *kwnames[] = {
43649 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43650 };
43651
43652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43654 if (SWIG_arg_fail(1)) SWIG_fail;
43655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43656 if (SWIG_arg_fail(2)) SWIG_fail;
43657 if (obj2) {
43658 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43659 if (SWIG_arg_fail(3)) SWIG_fail;
43660 }
43661 {
43662 PyThreadState* __tstate = wxPyBeginAllowThreads();
43663 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43664
43665 wxPyEndAllowThreads(__tstate);
43666 if (PyErr_Occurred()) SWIG_fail;
43667 }
43668 {
43669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43670 }
43671 return resultobj;
43672 fail:
43673 return NULL;
43674 }
43675
43676
43677 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43678 PyObject *resultobj;
43679 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43680 wxGBPosition *arg2 = 0 ;
43681 wxGBSpan *arg3 = 0 ;
43682 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43683 bool result;
43684 wxGBPosition temp2 ;
43685 wxGBSpan temp3 ;
43686 PyObject * obj0 = 0 ;
43687 PyObject * obj1 = 0 ;
43688 PyObject * obj2 = 0 ;
43689 PyObject * obj3 = 0 ;
43690 char *kwnames[] = {
43691 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43692 };
43693
43694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43696 if (SWIG_arg_fail(1)) SWIG_fail;
43697 {
43698 arg2 = &temp2;
43699 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43700 }
43701 {
43702 arg3 = &temp3;
43703 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43704 }
43705 if (obj3) {
43706 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43707 if (SWIG_arg_fail(4)) SWIG_fail;
43708 }
43709 {
43710 PyThreadState* __tstate = wxPyBeginAllowThreads();
43711 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43712
43713 wxPyEndAllowThreads(__tstate);
43714 if (PyErr_Occurred()) SWIG_fail;
43715 }
43716 {
43717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43718 }
43719 return resultobj;
43720 fail:
43721 return NULL;
43722 }
43723
43724
43725 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43726 PyObject *obj;
43727 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43728 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43729 Py_INCREF(obj);
43730 return Py_BuildValue((char *)"");
43731 }
43732 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43733 PyObject *resultobj;
43734 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43735 wxRelationship arg2 ;
43736 wxWindow *arg3 = (wxWindow *) 0 ;
43737 wxEdge arg4 ;
43738 int arg5 = (int) 0 ;
43739 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43740 PyObject * obj0 = 0 ;
43741 PyObject * obj1 = 0 ;
43742 PyObject * obj2 = 0 ;
43743 PyObject * obj3 = 0 ;
43744 PyObject * obj4 = 0 ;
43745 PyObject * obj5 = 0 ;
43746 char *kwnames[] = {
43747 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43748 };
43749
43750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43752 if (SWIG_arg_fail(1)) SWIG_fail;
43753 {
43754 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43755 if (SWIG_arg_fail(2)) SWIG_fail;
43756 }
43757 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43758 if (SWIG_arg_fail(3)) SWIG_fail;
43759 {
43760 arg4 = (wxEdge)(SWIG_As_int(obj3));
43761 if (SWIG_arg_fail(4)) SWIG_fail;
43762 }
43763 if (obj4) {
43764 {
43765 arg5 = (int)(SWIG_As_int(obj4));
43766 if (SWIG_arg_fail(5)) SWIG_fail;
43767 }
43768 }
43769 if (obj5) {
43770 {
43771 arg6 = (int)(SWIG_As_int(obj5));
43772 if (SWIG_arg_fail(6)) SWIG_fail;
43773 }
43774 }
43775 {
43776 PyThreadState* __tstate = wxPyBeginAllowThreads();
43777 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43778
43779 wxPyEndAllowThreads(__tstate);
43780 if (PyErr_Occurred()) SWIG_fail;
43781 }
43782 Py_INCREF(Py_None); resultobj = Py_None;
43783 return resultobj;
43784 fail:
43785 return NULL;
43786 }
43787
43788
43789 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43790 PyObject *resultobj;
43791 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43792 wxWindow *arg2 = (wxWindow *) 0 ;
43793 int arg3 = (int) 0 ;
43794 PyObject * obj0 = 0 ;
43795 PyObject * obj1 = 0 ;
43796 PyObject * obj2 = 0 ;
43797 char *kwnames[] = {
43798 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43799 };
43800
43801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43803 if (SWIG_arg_fail(1)) SWIG_fail;
43804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43805 if (SWIG_arg_fail(2)) SWIG_fail;
43806 if (obj2) {
43807 {
43808 arg3 = (int)(SWIG_As_int(obj2));
43809 if (SWIG_arg_fail(3)) SWIG_fail;
43810 }
43811 }
43812 {
43813 PyThreadState* __tstate = wxPyBeginAllowThreads();
43814 (arg1)->LeftOf(arg2,arg3);
43815
43816 wxPyEndAllowThreads(__tstate);
43817 if (PyErr_Occurred()) SWIG_fail;
43818 }
43819 Py_INCREF(Py_None); resultobj = Py_None;
43820 return resultobj;
43821 fail:
43822 return NULL;
43823 }
43824
43825
43826 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43827 PyObject *resultobj;
43828 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43829 wxWindow *arg2 = (wxWindow *) 0 ;
43830 int arg3 = (int) 0 ;
43831 PyObject * obj0 = 0 ;
43832 PyObject * obj1 = 0 ;
43833 PyObject * obj2 = 0 ;
43834 char *kwnames[] = {
43835 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43836 };
43837
43838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43840 if (SWIG_arg_fail(1)) SWIG_fail;
43841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43842 if (SWIG_arg_fail(2)) SWIG_fail;
43843 if (obj2) {
43844 {
43845 arg3 = (int)(SWIG_As_int(obj2));
43846 if (SWIG_arg_fail(3)) SWIG_fail;
43847 }
43848 }
43849 {
43850 PyThreadState* __tstate = wxPyBeginAllowThreads();
43851 (arg1)->RightOf(arg2,arg3);
43852
43853 wxPyEndAllowThreads(__tstate);
43854 if (PyErr_Occurred()) SWIG_fail;
43855 }
43856 Py_INCREF(Py_None); resultobj = Py_None;
43857 return resultobj;
43858 fail:
43859 return NULL;
43860 }
43861
43862
43863 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43864 PyObject *resultobj;
43865 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43866 wxWindow *arg2 = (wxWindow *) 0 ;
43867 int arg3 = (int) 0 ;
43868 PyObject * obj0 = 0 ;
43869 PyObject * obj1 = 0 ;
43870 PyObject * obj2 = 0 ;
43871 char *kwnames[] = {
43872 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43873 };
43874
43875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43877 if (SWIG_arg_fail(1)) SWIG_fail;
43878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43879 if (SWIG_arg_fail(2)) SWIG_fail;
43880 if (obj2) {
43881 {
43882 arg3 = (int)(SWIG_As_int(obj2));
43883 if (SWIG_arg_fail(3)) SWIG_fail;
43884 }
43885 }
43886 {
43887 PyThreadState* __tstate = wxPyBeginAllowThreads();
43888 (arg1)->Above(arg2,arg3);
43889
43890 wxPyEndAllowThreads(__tstate);
43891 if (PyErr_Occurred()) SWIG_fail;
43892 }
43893 Py_INCREF(Py_None); resultobj = Py_None;
43894 return resultobj;
43895 fail:
43896 return NULL;
43897 }
43898
43899
43900 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43901 PyObject *resultobj;
43902 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43903 wxWindow *arg2 = (wxWindow *) 0 ;
43904 int arg3 = (int) 0 ;
43905 PyObject * obj0 = 0 ;
43906 PyObject * obj1 = 0 ;
43907 PyObject * obj2 = 0 ;
43908 char *kwnames[] = {
43909 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43910 };
43911
43912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43914 if (SWIG_arg_fail(1)) SWIG_fail;
43915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43916 if (SWIG_arg_fail(2)) SWIG_fail;
43917 if (obj2) {
43918 {
43919 arg3 = (int)(SWIG_As_int(obj2));
43920 if (SWIG_arg_fail(3)) SWIG_fail;
43921 }
43922 }
43923 {
43924 PyThreadState* __tstate = wxPyBeginAllowThreads();
43925 (arg1)->Below(arg2,arg3);
43926
43927 wxPyEndAllowThreads(__tstate);
43928 if (PyErr_Occurred()) SWIG_fail;
43929 }
43930 Py_INCREF(Py_None); resultobj = Py_None;
43931 return resultobj;
43932 fail:
43933 return NULL;
43934 }
43935
43936
43937 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43938 PyObject *resultobj;
43939 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43940 wxWindow *arg2 = (wxWindow *) 0 ;
43941 wxEdge arg3 ;
43942 int arg4 = (int) 0 ;
43943 PyObject * obj0 = 0 ;
43944 PyObject * obj1 = 0 ;
43945 PyObject * obj2 = 0 ;
43946 PyObject * obj3 = 0 ;
43947 char *kwnames[] = {
43948 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43949 };
43950
43951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43953 if (SWIG_arg_fail(1)) SWIG_fail;
43954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43955 if (SWIG_arg_fail(2)) SWIG_fail;
43956 {
43957 arg3 = (wxEdge)(SWIG_As_int(obj2));
43958 if (SWIG_arg_fail(3)) SWIG_fail;
43959 }
43960 if (obj3) {
43961 {
43962 arg4 = (int)(SWIG_As_int(obj3));
43963 if (SWIG_arg_fail(4)) SWIG_fail;
43964 }
43965 }
43966 {
43967 PyThreadState* __tstate = wxPyBeginAllowThreads();
43968 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43969
43970 wxPyEndAllowThreads(__tstate);
43971 if (PyErr_Occurred()) SWIG_fail;
43972 }
43973 Py_INCREF(Py_None); resultobj = Py_None;
43974 return resultobj;
43975 fail:
43976 return NULL;
43977 }
43978
43979
43980 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43981 PyObject *resultobj;
43982 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43983 wxWindow *arg2 = (wxWindow *) 0 ;
43984 wxEdge arg3 ;
43985 int arg4 ;
43986 PyObject * obj0 = 0 ;
43987 PyObject * obj1 = 0 ;
43988 PyObject * obj2 = 0 ;
43989 PyObject * obj3 = 0 ;
43990 char *kwnames[] = {
43991 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43992 };
43993
43994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43996 if (SWIG_arg_fail(1)) SWIG_fail;
43997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43998 if (SWIG_arg_fail(2)) SWIG_fail;
43999 {
44000 arg3 = (wxEdge)(SWIG_As_int(obj2));
44001 if (SWIG_arg_fail(3)) SWIG_fail;
44002 }
44003 {
44004 arg4 = (int)(SWIG_As_int(obj3));
44005 if (SWIG_arg_fail(4)) SWIG_fail;
44006 }
44007 {
44008 PyThreadState* __tstate = wxPyBeginAllowThreads();
44009 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44010
44011 wxPyEndAllowThreads(__tstate);
44012 if (PyErr_Occurred()) SWIG_fail;
44013 }
44014 Py_INCREF(Py_None); resultobj = Py_None;
44015 return resultobj;
44016 fail:
44017 return NULL;
44018 }
44019
44020
44021 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44022 PyObject *resultobj;
44023 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44024 int arg2 ;
44025 PyObject * obj0 = 0 ;
44026 PyObject * obj1 = 0 ;
44027 char *kwnames[] = {
44028 (char *) "self",(char *) "val", NULL
44029 };
44030
44031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44033 if (SWIG_arg_fail(1)) SWIG_fail;
44034 {
44035 arg2 = (int)(SWIG_As_int(obj1));
44036 if (SWIG_arg_fail(2)) SWIG_fail;
44037 }
44038 {
44039 PyThreadState* __tstate = wxPyBeginAllowThreads();
44040 (arg1)->Absolute(arg2);
44041
44042 wxPyEndAllowThreads(__tstate);
44043 if (PyErr_Occurred()) SWIG_fail;
44044 }
44045 Py_INCREF(Py_None); resultobj = Py_None;
44046 return resultobj;
44047 fail:
44048 return NULL;
44049 }
44050
44051
44052 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44053 PyObject *resultobj;
44054 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44055 PyObject * obj0 = 0 ;
44056 char *kwnames[] = {
44057 (char *) "self", NULL
44058 };
44059
44060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44062 if (SWIG_arg_fail(1)) SWIG_fail;
44063 {
44064 PyThreadState* __tstate = wxPyBeginAllowThreads();
44065 (arg1)->Unconstrained();
44066
44067 wxPyEndAllowThreads(__tstate);
44068 if (PyErr_Occurred()) SWIG_fail;
44069 }
44070 Py_INCREF(Py_None); resultobj = Py_None;
44071 return resultobj;
44072 fail:
44073 return NULL;
44074 }
44075
44076
44077 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44078 PyObject *resultobj;
44079 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44080 PyObject * obj0 = 0 ;
44081 char *kwnames[] = {
44082 (char *) "self", NULL
44083 };
44084
44085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44087 if (SWIG_arg_fail(1)) SWIG_fail;
44088 {
44089 PyThreadState* __tstate = wxPyBeginAllowThreads();
44090 (arg1)->AsIs();
44091
44092 wxPyEndAllowThreads(__tstate);
44093 if (PyErr_Occurred()) SWIG_fail;
44094 }
44095 Py_INCREF(Py_None); resultobj = Py_None;
44096 return resultobj;
44097 fail:
44098 return NULL;
44099 }
44100
44101
44102 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44103 PyObject *resultobj;
44104 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44105 wxWindow *result;
44106 PyObject * obj0 = 0 ;
44107 char *kwnames[] = {
44108 (char *) "self", NULL
44109 };
44110
44111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44113 if (SWIG_arg_fail(1)) SWIG_fail;
44114 {
44115 PyThreadState* __tstate = wxPyBeginAllowThreads();
44116 result = (wxWindow *)(arg1)->GetOtherWindow();
44117
44118 wxPyEndAllowThreads(__tstate);
44119 if (PyErr_Occurred()) SWIG_fail;
44120 }
44121 {
44122 resultobj = wxPyMake_wxObject(result, 0);
44123 }
44124 return resultobj;
44125 fail:
44126 return NULL;
44127 }
44128
44129
44130 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44131 PyObject *resultobj;
44132 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44133 wxEdge result;
44134 PyObject * obj0 = 0 ;
44135 char *kwnames[] = {
44136 (char *) "self", NULL
44137 };
44138
44139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44141 if (SWIG_arg_fail(1)) SWIG_fail;
44142 {
44143 PyThreadState* __tstate = wxPyBeginAllowThreads();
44144 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44145
44146 wxPyEndAllowThreads(__tstate);
44147 if (PyErr_Occurred()) SWIG_fail;
44148 }
44149 resultobj = SWIG_From_int((result));
44150 return resultobj;
44151 fail:
44152 return NULL;
44153 }
44154
44155
44156 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44157 PyObject *resultobj;
44158 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44159 wxEdge arg2 ;
44160 PyObject * obj0 = 0 ;
44161 PyObject * obj1 = 0 ;
44162 char *kwnames[] = {
44163 (char *) "self",(char *) "which", NULL
44164 };
44165
44166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44168 if (SWIG_arg_fail(1)) SWIG_fail;
44169 {
44170 arg2 = (wxEdge)(SWIG_As_int(obj1));
44171 if (SWIG_arg_fail(2)) SWIG_fail;
44172 }
44173 {
44174 PyThreadState* __tstate = wxPyBeginAllowThreads();
44175 (arg1)->SetEdge((wxEdge )arg2);
44176
44177 wxPyEndAllowThreads(__tstate);
44178 if (PyErr_Occurred()) SWIG_fail;
44179 }
44180 Py_INCREF(Py_None); resultobj = Py_None;
44181 return resultobj;
44182 fail:
44183 return NULL;
44184 }
44185
44186
44187 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44188 PyObject *resultobj;
44189 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44190 int arg2 ;
44191 PyObject * obj0 = 0 ;
44192 PyObject * obj1 = 0 ;
44193 char *kwnames[] = {
44194 (char *) "self",(char *) "v", NULL
44195 };
44196
44197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44199 if (SWIG_arg_fail(1)) SWIG_fail;
44200 {
44201 arg2 = (int)(SWIG_As_int(obj1));
44202 if (SWIG_arg_fail(2)) SWIG_fail;
44203 }
44204 {
44205 PyThreadState* __tstate = wxPyBeginAllowThreads();
44206 (arg1)->SetValue(arg2);
44207
44208 wxPyEndAllowThreads(__tstate);
44209 if (PyErr_Occurred()) SWIG_fail;
44210 }
44211 Py_INCREF(Py_None); resultobj = Py_None;
44212 return resultobj;
44213 fail:
44214 return NULL;
44215 }
44216
44217
44218 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44219 PyObject *resultobj;
44220 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44221 int result;
44222 PyObject * obj0 = 0 ;
44223 char *kwnames[] = {
44224 (char *) "self", NULL
44225 };
44226
44227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44229 if (SWIG_arg_fail(1)) SWIG_fail;
44230 {
44231 PyThreadState* __tstate = wxPyBeginAllowThreads();
44232 result = (int)(arg1)->GetMargin();
44233
44234 wxPyEndAllowThreads(__tstate);
44235 if (PyErr_Occurred()) SWIG_fail;
44236 }
44237 {
44238 resultobj = SWIG_From_int((int)(result));
44239 }
44240 return resultobj;
44241 fail:
44242 return NULL;
44243 }
44244
44245
44246 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44247 PyObject *resultobj;
44248 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44249 int arg2 ;
44250 PyObject * obj0 = 0 ;
44251 PyObject * obj1 = 0 ;
44252 char *kwnames[] = {
44253 (char *) "self",(char *) "m", NULL
44254 };
44255
44256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44258 if (SWIG_arg_fail(1)) SWIG_fail;
44259 {
44260 arg2 = (int)(SWIG_As_int(obj1));
44261 if (SWIG_arg_fail(2)) SWIG_fail;
44262 }
44263 {
44264 PyThreadState* __tstate = wxPyBeginAllowThreads();
44265 (arg1)->SetMargin(arg2);
44266
44267 wxPyEndAllowThreads(__tstate);
44268 if (PyErr_Occurred()) SWIG_fail;
44269 }
44270 Py_INCREF(Py_None); resultobj = Py_None;
44271 return resultobj;
44272 fail:
44273 return NULL;
44274 }
44275
44276
44277 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44278 PyObject *resultobj;
44279 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44280 int result;
44281 PyObject * obj0 = 0 ;
44282 char *kwnames[] = {
44283 (char *) "self", NULL
44284 };
44285
44286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44288 if (SWIG_arg_fail(1)) SWIG_fail;
44289 {
44290 PyThreadState* __tstate = wxPyBeginAllowThreads();
44291 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44292
44293 wxPyEndAllowThreads(__tstate);
44294 if (PyErr_Occurred()) SWIG_fail;
44295 }
44296 {
44297 resultobj = SWIG_From_int((int)(result));
44298 }
44299 return resultobj;
44300 fail:
44301 return NULL;
44302 }
44303
44304
44305 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44306 PyObject *resultobj;
44307 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44308 int result;
44309 PyObject * obj0 = 0 ;
44310 char *kwnames[] = {
44311 (char *) "self", NULL
44312 };
44313
44314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44316 if (SWIG_arg_fail(1)) SWIG_fail;
44317 {
44318 PyThreadState* __tstate = wxPyBeginAllowThreads();
44319 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44320
44321 wxPyEndAllowThreads(__tstate);
44322 if (PyErr_Occurred()) SWIG_fail;
44323 }
44324 {
44325 resultobj = SWIG_From_int((int)(result));
44326 }
44327 return resultobj;
44328 fail:
44329 return NULL;
44330 }
44331
44332
44333 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44334 PyObject *resultobj;
44335 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44336 int result;
44337 PyObject * obj0 = 0 ;
44338 char *kwnames[] = {
44339 (char *) "self", NULL
44340 };
44341
44342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44344 if (SWIG_arg_fail(1)) SWIG_fail;
44345 {
44346 PyThreadState* __tstate = wxPyBeginAllowThreads();
44347 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44348
44349 wxPyEndAllowThreads(__tstate);
44350 if (PyErr_Occurred()) SWIG_fail;
44351 }
44352 {
44353 resultobj = SWIG_From_int((int)(result));
44354 }
44355 return resultobj;
44356 fail:
44357 return NULL;
44358 }
44359
44360
44361 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44362 PyObject *resultobj;
44363 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44364 bool result;
44365 PyObject * obj0 = 0 ;
44366 char *kwnames[] = {
44367 (char *) "self", NULL
44368 };
44369
44370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44372 if (SWIG_arg_fail(1)) SWIG_fail;
44373 {
44374 PyThreadState* __tstate = wxPyBeginAllowThreads();
44375 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44376
44377 wxPyEndAllowThreads(__tstate);
44378 if (PyErr_Occurred()) SWIG_fail;
44379 }
44380 {
44381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44382 }
44383 return resultobj;
44384 fail:
44385 return NULL;
44386 }
44387
44388
44389 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44390 PyObject *resultobj;
44391 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44392 bool arg2 ;
44393 PyObject * obj0 = 0 ;
44394 PyObject * obj1 = 0 ;
44395 char *kwnames[] = {
44396 (char *) "self",(char *) "d", NULL
44397 };
44398
44399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44401 if (SWIG_arg_fail(1)) SWIG_fail;
44402 {
44403 arg2 = (bool)(SWIG_As_bool(obj1));
44404 if (SWIG_arg_fail(2)) SWIG_fail;
44405 }
44406 {
44407 PyThreadState* __tstate = wxPyBeginAllowThreads();
44408 (arg1)->SetDone(arg2);
44409
44410 wxPyEndAllowThreads(__tstate);
44411 if (PyErr_Occurred()) SWIG_fail;
44412 }
44413 Py_INCREF(Py_None); resultobj = Py_None;
44414 return resultobj;
44415 fail:
44416 return NULL;
44417 }
44418
44419
44420 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44421 PyObject *resultobj;
44422 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44423 wxRelationship result;
44424 PyObject * obj0 = 0 ;
44425 char *kwnames[] = {
44426 (char *) "self", NULL
44427 };
44428
44429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44431 if (SWIG_arg_fail(1)) SWIG_fail;
44432 {
44433 PyThreadState* __tstate = wxPyBeginAllowThreads();
44434 result = (wxRelationship)(arg1)->GetRelationship();
44435
44436 wxPyEndAllowThreads(__tstate);
44437 if (PyErr_Occurred()) SWIG_fail;
44438 }
44439 resultobj = SWIG_From_int((result));
44440 return resultobj;
44441 fail:
44442 return NULL;
44443 }
44444
44445
44446 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44447 PyObject *resultobj;
44448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44449 wxRelationship arg2 ;
44450 PyObject * obj0 = 0 ;
44451 PyObject * obj1 = 0 ;
44452 char *kwnames[] = {
44453 (char *) "self",(char *) "r", NULL
44454 };
44455
44456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44458 if (SWIG_arg_fail(1)) SWIG_fail;
44459 {
44460 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44461 if (SWIG_arg_fail(2)) SWIG_fail;
44462 }
44463 {
44464 PyThreadState* __tstate = wxPyBeginAllowThreads();
44465 (arg1)->SetRelationship((wxRelationship )arg2);
44466
44467 wxPyEndAllowThreads(__tstate);
44468 if (PyErr_Occurred()) SWIG_fail;
44469 }
44470 Py_INCREF(Py_None); resultobj = Py_None;
44471 return resultobj;
44472 fail:
44473 return NULL;
44474 }
44475
44476
44477 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44478 PyObject *resultobj;
44479 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44480 wxWindow *arg2 = (wxWindow *) 0 ;
44481 bool result;
44482 PyObject * obj0 = 0 ;
44483 PyObject * obj1 = 0 ;
44484 char *kwnames[] = {
44485 (char *) "self",(char *) "otherW", NULL
44486 };
44487
44488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44490 if (SWIG_arg_fail(1)) SWIG_fail;
44491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44492 if (SWIG_arg_fail(2)) SWIG_fail;
44493 {
44494 PyThreadState* __tstate = wxPyBeginAllowThreads();
44495 result = (bool)(arg1)->ResetIfWin(arg2);
44496
44497 wxPyEndAllowThreads(__tstate);
44498 if (PyErr_Occurred()) SWIG_fail;
44499 }
44500 {
44501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44502 }
44503 return resultobj;
44504 fail:
44505 return NULL;
44506 }
44507
44508
44509 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44510 PyObject *resultobj;
44511 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44512 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44513 wxWindow *arg3 = (wxWindow *) 0 ;
44514 bool result;
44515 PyObject * obj0 = 0 ;
44516 PyObject * obj1 = 0 ;
44517 PyObject * obj2 = 0 ;
44518 char *kwnames[] = {
44519 (char *) "self",(char *) "constraints",(char *) "win", NULL
44520 };
44521
44522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44524 if (SWIG_arg_fail(1)) SWIG_fail;
44525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44526 if (SWIG_arg_fail(2)) SWIG_fail;
44527 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44528 if (SWIG_arg_fail(3)) SWIG_fail;
44529 {
44530 PyThreadState* __tstate = wxPyBeginAllowThreads();
44531 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44532
44533 wxPyEndAllowThreads(__tstate);
44534 if (PyErr_Occurred()) SWIG_fail;
44535 }
44536 {
44537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44538 }
44539 return resultobj;
44540 fail:
44541 return NULL;
44542 }
44543
44544
44545 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44546 PyObject *resultobj;
44547 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44548 wxEdge arg2 ;
44549 wxWindow *arg3 = (wxWindow *) 0 ;
44550 wxWindow *arg4 = (wxWindow *) 0 ;
44551 int result;
44552 PyObject * obj0 = 0 ;
44553 PyObject * obj1 = 0 ;
44554 PyObject * obj2 = 0 ;
44555 PyObject * obj3 = 0 ;
44556 char *kwnames[] = {
44557 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44558 };
44559
44560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44562 if (SWIG_arg_fail(1)) SWIG_fail;
44563 {
44564 arg2 = (wxEdge)(SWIG_As_int(obj1));
44565 if (SWIG_arg_fail(2)) SWIG_fail;
44566 }
44567 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44568 if (SWIG_arg_fail(3)) SWIG_fail;
44569 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44570 if (SWIG_arg_fail(4)) SWIG_fail;
44571 {
44572 PyThreadState* __tstate = wxPyBeginAllowThreads();
44573 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44574
44575 wxPyEndAllowThreads(__tstate);
44576 if (PyErr_Occurred()) SWIG_fail;
44577 }
44578 {
44579 resultobj = SWIG_From_int((int)(result));
44580 }
44581 return resultobj;
44582 fail:
44583 return NULL;
44584 }
44585
44586
44587 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44588 PyObject *obj;
44589 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44590 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44591 Py_INCREF(obj);
44592 return Py_BuildValue((char *)"");
44593 }
44594 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44595 PyObject *resultobj;
44596 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44597 wxIndividualLayoutConstraint *result;
44598 PyObject * obj0 = 0 ;
44599 char *kwnames[] = {
44600 (char *) "self", NULL
44601 };
44602
44603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44605 if (SWIG_arg_fail(1)) SWIG_fail;
44606 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44607
44608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44609 return resultobj;
44610 fail:
44611 return NULL;
44612 }
44613
44614
44615 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44616 PyObject *resultobj;
44617 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44618 wxIndividualLayoutConstraint *result;
44619 PyObject * obj0 = 0 ;
44620 char *kwnames[] = {
44621 (char *) "self", NULL
44622 };
44623
44624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44626 if (SWIG_arg_fail(1)) SWIG_fail;
44627 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44628
44629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44630 return resultobj;
44631 fail:
44632 return NULL;
44633 }
44634
44635
44636 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44637 PyObject *resultobj;
44638 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44639 wxIndividualLayoutConstraint *result;
44640 PyObject * obj0 = 0 ;
44641 char *kwnames[] = {
44642 (char *) "self", NULL
44643 };
44644
44645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44647 if (SWIG_arg_fail(1)) SWIG_fail;
44648 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44649
44650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44651 return resultobj;
44652 fail:
44653 return NULL;
44654 }
44655
44656
44657 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44658 PyObject *resultobj;
44659 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44660 wxIndividualLayoutConstraint *result;
44661 PyObject * obj0 = 0 ;
44662 char *kwnames[] = {
44663 (char *) "self", NULL
44664 };
44665
44666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44668 if (SWIG_arg_fail(1)) SWIG_fail;
44669 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44670
44671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44672 return resultobj;
44673 fail:
44674 return NULL;
44675 }
44676
44677
44678 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44679 PyObject *resultobj;
44680 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44681 wxIndividualLayoutConstraint *result;
44682 PyObject * obj0 = 0 ;
44683 char *kwnames[] = {
44684 (char *) "self", NULL
44685 };
44686
44687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44689 if (SWIG_arg_fail(1)) SWIG_fail;
44690 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44691
44692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44693 return resultobj;
44694 fail:
44695 return NULL;
44696 }
44697
44698
44699 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44700 PyObject *resultobj;
44701 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44702 wxIndividualLayoutConstraint *result;
44703 PyObject * obj0 = 0 ;
44704 char *kwnames[] = {
44705 (char *) "self", NULL
44706 };
44707
44708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44710 if (SWIG_arg_fail(1)) SWIG_fail;
44711 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44712
44713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44714 return resultobj;
44715 fail:
44716 return NULL;
44717 }
44718
44719
44720 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44721 PyObject *resultobj;
44722 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44723 wxIndividualLayoutConstraint *result;
44724 PyObject * obj0 = 0 ;
44725 char *kwnames[] = {
44726 (char *) "self", NULL
44727 };
44728
44729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44731 if (SWIG_arg_fail(1)) SWIG_fail;
44732 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44733
44734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44735 return resultobj;
44736 fail:
44737 return NULL;
44738 }
44739
44740
44741 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44742 PyObject *resultobj;
44743 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44744 wxIndividualLayoutConstraint *result;
44745 PyObject * obj0 = 0 ;
44746 char *kwnames[] = {
44747 (char *) "self", NULL
44748 };
44749
44750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44752 if (SWIG_arg_fail(1)) SWIG_fail;
44753 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44754
44755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44756 return resultobj;
44757 fail:
44758 return NULL;
44759 }
44760
44761
44762 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44763 PyObject *resultobj;
44764 wxLayoutConstraints *result;
44765 char *kwnames[] = {
44766 NULL
44767 };
44768
44769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44770 {
44771 PyThreadState* __tstate = wxPyBeginAllowThreads();
44772 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44773
44774 wxPyEndAllowThreads(__tstate);
44775 if (PyErr_Occurred()) SWIG_fail;
44776 }
44777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44778 return resultobj;
44779 fail:
44780 return NULL;
44781 }
44782
44783
44784 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44785 PyObject *resultobj;
44786 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44787 wxWindow *arg2 = (wxWindow *) 0 ;
44788 int *arg3 = (int *) 0 ;
44789 bool result;
44790 int temp3 ;
44791 int res3 = 0 ;
44792 PyObject * obj0 = 0 ;
44793 PyObject * obj1 = 0 ;
44794 char *kwnames[] = {
44795 (char *) "self",(char *) "win", NULL
44796 };
44797
44798 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44801 if (SWIG_arg_fail(1)) SWIG_fail;
44802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44803 if (SWIG_arg_fail(2)) SWIG_fail;
44804 {
44805 PyThreadState* __tstate = wxPyBeginAllowThreads();
44806 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44807
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 {
44812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44813 }
44814 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44815 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44816 return resultobj;
44817 fail:
44818 return NULL;
44819 }
44820
44821
44822 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44823 PyObject *resultobj;
44824 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44825 bool result;
44826 PyObject * obj0 = 0 ;
44827 char *kwnames[] = {
44828 (char *) "self", NULL
44829 };
44830
44831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44833 if (SWIG_arg_fail(1)) SWIG_fail;
44834 {
44835 PyThreadState* __tstate = wxPyBeginAllowThreads();
44836 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44837
44838 wxPyEndAllowThreads(__tstate);
44839 if (PyErr_Occurred()) SWIG_fail;
44840 }
44841 {
44842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44843 }
44844 return resultobj;
44845 fail:
44846 return NULL;
44847 }
44848
44849
44850 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44851 PyObject *obj;
44852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44853 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44854 Py_INCREF(obj);
44855 return Py_BuildValue((char *)"");
44856 }
44857 static PyMethodDef SwigMethods[] = {
44858 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44859 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44860 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44863 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44884 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44897 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44912 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44965 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44993 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45012 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45014 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45022 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45023 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45035 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45047 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45051 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45057 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45067 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45077 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45081 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45156 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45158 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45160 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45162 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45164 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45166 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45168 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45170 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45172 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45174 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45176 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45178 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45180 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45194 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45212 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45215 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45218 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45230 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45235 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45241 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45247 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45310 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45317 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45353 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45363 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45369 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45371 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45373 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45376 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45380 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45383 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45386 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45388 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45393 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45401 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45405 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45408 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45410 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45414 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45431 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45433 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45436 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45438 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45442 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45446 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45457 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45460 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45463 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45467 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45474 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45479 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45484 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45488 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45533 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45553 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45560 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45564 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45574 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45746 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45788 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45802 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45805 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45860 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45887 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45931 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45939 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45958 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45959 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45996 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46026 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46029 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46033 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46036 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46046 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46058 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46070 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46080 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46090 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46104 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46111 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46112 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46113 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46114 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46115 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46120 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46147 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46159 { NULL, NULL, 0, NULL }
46160 };
46161
46162
46163 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46164
46165 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46166 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46167 }
46168 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46169 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46170 }
46171 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46172 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46173 }
46174 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46175 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46176 }
46177 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46178 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46179 }
46180 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46181 return (void *)((wxSizer *) ((wxGridSizer *) x));
46182 }
46183 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46184 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46185 }
46186 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46187 return (void *)((wxSizer *) ((wxPySizer *) x));
46188 }
46189 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46190 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46191 }
46192 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46193 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46194 }
46195 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46196 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46197 }
46198 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46199 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46200 }
46201 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46202 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46203 }
46204 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46205 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46206 }
46207 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46208 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46209 }
46210 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46211 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46212 }
46213 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46214 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46215 }
46216 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46217 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46218 }
46219 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46220 return (void *)((wxEvent *) ((wxPyEvent *) x));
46221 }
46222 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46223 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46224 }
46225 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46226 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46227 }
46228 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46229 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46230 }
46231 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46232 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46233 }
46234 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46235 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46236 }
46237 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46238 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46239 }
46240 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46241 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46242 }
46243 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46244 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46245 }
46246 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46247 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46248 }
46249 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46250 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46251 }
46252 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46253 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46254 }
46255 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46256 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46257 }
46258 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46259 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46260 }
46261 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46262 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46263 }
46264 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46265 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46266 }
46267 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46268 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46269 }
46270 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46271 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46272 }
46273 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46274 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46275 }
46276 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46277 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46278 }
46279 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46280 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46281 }
46282 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46283 return (void *)((wxEvent *) ((wxShowEvent *) x));
46284 }
46285 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46286 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46287 }
46288 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46289 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46290 }
46291 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46292 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46293 }
46294 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46295 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46296 }
46297 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46298 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46299 }
46300 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46301 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46302 }
46303 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46304 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46305 }
46306 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46307 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46308 }
46309 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46310 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46311 }
46312 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46313 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46314 }
46315 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46316 return (void *)((wxControl *) ((wxControlWithItems *) x));
46317 }
46318 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46319 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46320 }
46321 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46322 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46323 }
46324 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46325 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46326 }
46327 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46328 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46329 }
46330 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46331 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46332 }
46333 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46334 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46335 }
46336 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46337 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46338 }
46339 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46340 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46341 }
46342 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46343 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46344 }
46345 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46346 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46347 }
46348 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46349 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46350 }
46351 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46352 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46353 }
46354 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46355 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46356 }
46357 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46358 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46359 }
46360 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46361 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46362 }
46363 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46364 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46365 }
46366 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46367 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46368 }
46369 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46370 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46371 }
46372 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46373 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46374 }
46375 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46376 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46377 }
46378 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46379 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46380 }
46381 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46382 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46383 }
46384 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46385 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46386 }
46387 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46388 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46389 }
46390 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46391 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46392 }
46393 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46394 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46395 }
46396 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46397 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46398 }
46399 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46400 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46401 }
46402 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46403 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46404 }
46405 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46406 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46407 }
46408 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46409 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46410 }
46411 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46412 return (void *)((wxObject *) ((wxSizerItem *) x));
46413 }
46414 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46415 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46416 }
46417 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46418 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46419 }
46420 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46421 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46422 }
46423 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46424 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46425 }
46426 static void *_p_wxSizerTo_p_wxObject(void *x) {
46427 return (void *)((wxObject *) ((wxSizer *) x));
46428 }
46429 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46430 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46431 }
46432 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46433 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46434 }
46435 static void *_p_wxEventTo_p_wxObject(void *x) {
46436 return (void *)((wxObject *) ((wxEvent *) x));
46437 }
46438 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46439 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46440 }
46441 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46442 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46443 }
46444 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46445 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46446 }
46447 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46448 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46449 }
46450 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46451 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46452 }
46453 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46454 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46455 }
46456 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46457 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46458 }
46459 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46460 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46461 }
46462 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46463 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46464 }
46465 static void *_p_wxControlTo_p_wxObject(void *x) {
46466 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46467 }
46468 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46469 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46470 }
46471 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46472 return (void *)((wxObject *) ((wxFSFile *) x));
46473 }
46474 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46475 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46476 }
46477 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46478 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46479 }
46480 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46481 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46482 }
46483 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46484 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46485 }
46486 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46487 return (void *)((wxObject *) ((wxMenuItem *) x));
46488 }
46489 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46490 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46491 }
46492 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46493 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46494 }
46495 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46496 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46497 }
46498 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46499 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46500 }
46501 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46502 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46503 }
46504 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46505 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46506 }
46507 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46508 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46509 }
46510 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46511 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46512 }
46513 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46514 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46515 }
46516 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46517 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46518 }
46519 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46520 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46521 }
46522 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46523 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46524 }
46525 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46526 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46527 }
46528 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46529 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46530 }
46531 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46532 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46533 }
46534 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46535 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46536 }
46537 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46538 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46539 }
46540 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46541 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46542 }
46543 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46544 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46545 }
46546 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46547 return (void *)((wxObject *) ((wxImageHandler *) x));
46548 }
46549 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46550 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46551 }
46552 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46553 return (void *)((wxObject *) ((wxEvtHandler *) x));
46554 }
46555 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46556 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46557 }
46558 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46559 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46560 }
46561 static void *_p_wxImageTo_p_wxObject(void *x) {
46562 return (void *)((wxObject *) ((wxImage *) x));
46563 }
46564 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46565 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46566 }
46567 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46568 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46569 }
46570 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46571 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46572 }
46573 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46574 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46575 }
46576 static void *_p_wxWindowTo_p_wxObject(void *x) {
46577 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46578 }
46579 static void *_p_wxMenuTo_p_wxObject(void *x) {
46580 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46581 }
46582 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46583 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46584 }
46585 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46586 return (void *)((wxObject *) ((wxFileSystem *) x));
46587 }
46588 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46589 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46590 }
46591 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46592 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46593 }
46594 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46595 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46596 }
46597 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46598 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46599 }
46600 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46601 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46602 }
46603 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46604 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46605 }
46606 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46607 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46608 }
46609 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46610 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46611 }
46612 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46613 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46614 }
46615 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46616 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46617 }
46618 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46619 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46620 }
46621 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46622 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46623 }
46624 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46625 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46626 }
46627 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46628 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46629 }
46630 static void *_p_wxControlTo_p_wxWindow(void *x) {
46631 return (void *)((wxWindow *) ((wxControl *) x));
46632 }
46633 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46634 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46635 }
46636 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46637 return (void *)((wxWindow *) ((wxMenuBar *) x));
46638 }
46639 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46640 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46641 }
46642 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46643 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46644 }
46645 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46646 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46647 }
46648 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46649 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46650 }
46651 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46652 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46653 }
46654 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46655 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46656 }
46657 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46658 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46659 }
46660 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46661 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46662 }
46663 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46664 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46665 }
46666 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46667 return (void *)((wxValidator *) ((wxPyValidator *) x));
46668 }
46669 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}};
46670 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}};
46671 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}};
46672 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}};
46673 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}};
46674 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}};
46675 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}};
46676 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}};
46677 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}};
46678 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}};
46679 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}};
46680 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}};
46681 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}};
46682 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}};
46683 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}};
46684 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}};
46685 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}};
46686 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}};
46687 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}};
46688 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}};
46689 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}};
46690 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}};
46691 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}};
46692 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}};
46693 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}};
46694 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}};
46695 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}};
46696 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}};
46697 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}};
46698 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}};
46699 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}};
46700 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}};
46701 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}};
46702 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}};
46703 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}};
46704 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}};
46705 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}};
46706 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}};
46707 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}};
46708 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}};
46709 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}};
46710 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}};
46711 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}};
46712 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}};
46713 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}};
46714 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}};
46715 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}};
46716 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}};
46717 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}};
46718 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}};
46719 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}};
46720 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}};
46721 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}};
46722 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}};
46723 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}};
46724 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}};
46725 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}};
46726 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}};
46727 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}};
46728 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}};
46729 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}};
46730 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}};
46731 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}};
46732 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}};
46733 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}};
46734 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}};
46735 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}};
46736 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}};
46737 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}};
46738 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}};
46739 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}};
46740 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}};
46741 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}};
46742 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}};
46743 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}};
46744 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}};
46745 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}};
46746 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}};
46747 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}};
46748 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}};
46749 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}};
46750 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}};
46751 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}};
46752 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}};
46753 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}};
46754 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}};
46755 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}};
46756 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}};
46757 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}};
46758 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}};
46759 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}};
46760 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}};
46761 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}};
46762 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}};
46763 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}};
46764 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}};
46765 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}};
46766 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}};
46767 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}};
46768 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}};
46769 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}};
46770 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}};
46771 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}};
46772 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}};
46773 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}};
46774 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}};
46775 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}};
46776 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}};
46777 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}};
46778 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}};
46779 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}};
46780 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}};
46781 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}};
46782 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}};
46783 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}};
46784 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}};
46785 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}};
46786 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}};
46787 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}};
46788 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}};
46789 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}};
46790 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}};
46791 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}};
46792 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}};
46793 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}};
46794 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}};
46795 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}};
46796
46797 static swig_type_info *swig_types_initial[] = {
46798 _swigt__p_wxLayoutConstraints,
46799 _swigt__p_wxRealPoint,
46800 _swigt__p_wxSizerItem,
46801 _swigt__p_wxGBSizerItem,
46802 _swigt__p_wxScrollEvent,
46803 _swigt__p_wxEventLoop,
46804 _swigt__p_wxIndividualLayoutConstraint,
46805 _swigt__p_wxSizer,
46806 _swigt__p_wxBoxSizer,
46807 _swigt__p_wxStaticBoxSizer,
46808 _swigt__p_wxGridBagSizer,
46809 _swigt__p_wxAcceleratorEntry,
46810 _swigt__p_wxUpdateUIEvent,
46811 _swigt__p_wxEvent,
46812 _swigt__p_wxMenu,
46813 _swigt__p_wxGridSizer,
46814 _swigt__p_wxFlexGridSizer,
46815 _swigt__p_wxInitDialogEvent,
46816 _swigt__p_wxItemContainer,
46817 _swigt__p_wxNcPaintEvent,
46818 _swigt__p_wxPaintEvent,
46819 _swigt__p_wxSysColourChangedEvent,
46820 _swigt__p_wxMouseCaptureChangedEvent,
46821 _swigt__p_wxDisplayChangedEvent,
46822 _swigt__p_wxPaletteChangedEvent,
46823 _swigt__p_wxControl,
46824 _swigt__p_wxFont,
46825 _swigt__p_wxMenuBarBase,
46826 _swigt__p_wxSetCursorEvent,
46827 _swigt__p_wxFSFile,
46828 _swigt__p_wxCaret,
46829 _swigt__ptrdiff_t,
46830 _swigt__std__ptrdiff_t,
46831 _swigt__p_wxRegion,
46832 _swigt__p_wxPoint2D,
46833 _swigt__p_int,
46834 _swigt__p_wxSize,
46835 _swigt__p_wxDC,
46836 _swigt__p_wxPySizer,
46837 _swigt__p_wxVisualAttributes,
46838 _swigt__p_wxNotifyEvent,
46839 _swigt__p_wxPyEvent,
46840 _swigt__p_wxPropagationDisabler,
46841 _swigt__p_form_ops_t,
46842 _swigt__p_wxAppTraits,
46843 _swigt__p_wxArrayString,
46844 _swigt__p_wxShowEvent,
46845 _swigt__p_wxToolTip,
46846 _swigt__p_wxMoveEvent,
46847 _swigt__p_wxSizeEvent,
46848 _swigt__p_wxActivateEvent,
46849 _swigt__p_wxIconizeEvent,
46850 _swigt__p_wxMaximizeEvent,
46851 _swigt__p_wxQueryNewPaletteEvent,
46852 _swigt__p_wxWindowCreateEvent,
46853 _swigt__p_wxIdleEvent,
46854 _swigt__p_wxDateEvent,
46855 _swigt__p_wxMenuItem,
46856 _swigt__p_wxStaticBox,
46857 _swigt__p_long,
46858 _swigt__p_wxDuplexMode,
46859 _swigt__p_wxTIFFHandler,
46860 _swigt__p_wxXPMHandler,
46861 _swigt__p_wxPNMHandler,
46862 _swigt__p_wxJPEGHandler,
46863 _swigt__p_wxPCXHandler,
46864 _swigt__p_wxGIFHandler,
46865 _swigt__p_wxPNGHandler,
46866 _swigt__p_wxANIHandler,
46867 _swigt__p_wxMemoryFSHandler,
46868 _swigt__p_wxZipFSHandler,
46869 _swigt__p_wxInternetFSHandler,
46870 _swigt__p_wxPyFileSystemHandler,
46871 _swigt__p_wxEvtHandler,
46872 _swigt__p_wxCURHandler,
46873 _swigt__p_wxICOHandler,
46874 _swigt__p_wxBMPHandler,
46875 _swigt__p_wxImageHandler,
46876 _swigt__p_wxFileSystemHandler,
46877 _swigt__p_wxRect,
46878 _swigt__p_wxButton,
46879 _swigt__p_wxGBSpan,
46880 _swigt__p_wxPropagateOnce,
46881 _swigt__p_wxAcceleratorTable,
46882 _swigt__p_wxStdDialogButtonSizer,
46883 _swigt__p_char,
46884 _swigt__p_wxGBPosition,
46885 _swigt__p_wxImage,
46886 _swigt__p_wxFrame,
46887 _swigt__p_wxScrollWinEvent,
46888 _swigt__p_wxPaperSize,
46889 _swigt__p_wxImageHistogram,
46890 _swigt__p_wxPoint,
46891 _swigt__p_wxCursor,
46892 _swigt__p_wxObject,
46893 _swigt__p_wxInputStream,
46894 _swigt__p_wxOutputStream,
46895 _swigt__p_wxPyInputStream,
46896 _swigt__p_wxDateTime,
46897 _swigt__p_wxKeyEvent,
46898 _swigt__p_wxNavigationKeyEvent,
46899 _swigt__p_wxWindowDestroyEvent,
46900 _swigt__p_unsigned_long,
46901 _swigt__p_wxWindow,
46902 _swigt__p_wxMenuBar,
46903 _swigt__p_wxFileSystem,
46904 _swigt__p_wxBitmap,
46905 _swigt__unsigned_int,
46906 _swigt__p_unsigned_int,
46907 _swigt__p_wxMenuEvent,
46908 _swigt__p_wxContextMenuEvent,
46909 _swigt__p_unsigned_char,
46910 _swigt__p_wxEraseEvent,
46911 _swigt__p_wxMouseEvent,
46912 _swigt__p_wxCloseEvent,
46913 _swigt__p_wxPyApp,
46914 _swigt__p_wxCommandEvent,
46915 _swigt__p_wxPyCommandEvent,
46916 _swigt__p_wxPyDropTarget,
46917 _swigt__p_wxQuantize,
46918 _swigt__p_wxChildFocusEvent,
46919 _swigt__p_wxFocusEvent,
46920 _swigt__p_wxDropFilesEvent,
46921 _swigt__p_wxControlWithItems,
46922 _swigt__p_wxColour,
46923 _swigt__p_wxValidator,
46924 _swigt__p_wxPyValidator,
46925 0
46926 };
46927
46928
46929 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46930
46931 static swig_const_info swig_const_table[] = {
46932 {0, 0, 0, 0.0, 0, 0}};
46933
46934 #ifdef __cplusplus
46935 }
46936 #endif
46937
46938
46939 #ifdef __cplusplus
46940 extern "C" {
46941 #endif
46942
46943 /* Python-specific SWIG API */
46944 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46945 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46946 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46947
46948 /* -----------------------------------------------------------------------------
46949 * global variable support code.
46950 * ----------------------------------------------------------------------------- */
46951
46952 typedef struct swig_globalvar {
46953 char *name; /* Name of global variable */
46954 PyObject *(*get_attr)(); /* Return the current value */
46955 int (*set_attr)(PyObject *); /* Set the value */
46956 struct swig_globalvar *next;
46957 } swig_globalvar;
46958
46959 typedef struct swig_varlinkobject {
46960 PyObject_HEAD
46961 swig_globalvar *vars;
46962 } swig_varlinkobject;
46963
46964 static PyObject *
46965 swig_varlink_repr(swig_varlinkobject *v) {
46966 v = v;
46967 return PyString_FromString("<Swig global variables>");
46968 }
46969
46970 static int
46971 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46972 swig_globalvar *var;
46973 flags = flags;
46974 fprintf(fp,"Swig global variables { ");
46975 for (var = v->vars; var; var=var->next) {
46976 fprintf(fp,"%s", var->name);
46977 if (var->next) fprintf(fp,", ");
46978 }
46979 fprintf(fp," }\n");
46980 return 0;
46981 }
46982
46983 static PyObject *
46984 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46985 swig_globalvar *var = v->vars;
46986 while (var) {
46987 if (strcmp(var->name,n) == 0) {
46988 return (*var->get_attr)();
46989 }
46990 var = var->next;
46991 }
46992 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46993 return NULL;
46994 }
46995
46996 static int
46997 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46998 swig_globalvar *var = v->vars;
46999 while (var) {
47000 if (strcmp(var->name,n) == 0) {
47001 return (*var->set_attr)(p);
47002 }
47003 var = var->next;
47004 }
47005 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47006 return 1;
47007 }
47008
47009 static PyTypeObject varlinktype = {
47010 PyObject_HEAD_INIT(0)
47011 0, /* Number of items in variable part (ob_size) */
47012 (char *)"swigvarlink", /* Type name (tp_name) */
47013 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47014 0, /* Itemsize (tp_itemsize) */
47015 0, /* Deallocator (tp_dealloc) */
47016 (printfunc) swig_varlink_print, /* Print (tp_print) */
47017 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47018 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47019 0, /* tp_compare */
47020 (reprfunc) swig_varlink_repr, /* tp_repr */
47021 0, /* tp_as_number */
47022 0, /* tp_as_sequence */
47023 0, /* tp_as_mapping */
47024 0, /* tp_hash */
47025 0, /* tp_call */
47026 0, /* tp_str */
47027 0, /* tp_getattro */
47028 0, /* tp_setattro */
47029 0, /* tp_as_buffer */
47030 0, /* tp_flags */
47031 0, /* tp_doc */
47032 #if PY_VERSION_HEX >= 0x02000000
47033 0, /* tp_traverse */
47034 0, /* tp_clear */
47035 #endif
47036 #if PY_VERSION_HEX >= 0x02010000
47037 0, /* tp_richcompare */
47038 0, /* tp_weaklistoffset */
47039 #endif
47040 #if PY_VERSION_HEX >= 0x02020000
47041 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47042 #endif
47043 #if PY_VERSION_HEX >= 0x02030000
47044 0, /* tp_del */
47045 #endif
47046 #ifdef COUNT_ALLOCS
47047 0,0,0,0 /* tp_alloc -> tp_next */
47048 #endif
47049 };
47050
47051 /* Create a variable linking object for use later */
47052 static PyObject *
47053 SWIG_Python_newvarlink(void) {
47054 swig_varlinkobject *result = 0;
47055 result = PyMem_NEW(swig_varlinkobject,1);
47056 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47057 result->ob_type = &varlinktype;
47058 result->vars = 0;
47059 result->ob_refcnt = 0;
47060 Py_XINCREF((PyObject *) result);
47061 return ((PyObject*) result);
47062 }
47063
47064 static void
47065 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47066 swig_varlinkobject *v;
47067 swig_globalvar *gv;
47068 v= (swig_varlinkobject *) p;
47069 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47070 gv->name = (char *) malloc(strlen(name)+1);
47071 strcpy(gv->name,name);
47072 gv->get_attr = get_attr;
47073 gv->set_attr = set_attr;
47074 gv->next = v->vars;
47075 v->vars = gv;
47076 }
47077
47078 /* -----------------------------------------------------------------------------
47079 * constants/methods manipulation
47080 * ----------------------------------------------------------------------------- */
47081
47082 /* Install Constants */
47083 static void
47084 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47085 PyObject *obj = 0;
47086 size_t i;
47087 for (i = 0; constants[i].type; i++) {
47088 switch(constants[i].type) {
47089 case SWIG_PY_INT:
47090 obj = PyInt_FromLong(constants[i].lvalue);
47091 break;
47092 case SWIG_PY_FLOAT:
47093 obj = PyFloat_FromDouble(constants[i].dvalue);
47094 break;
47095 case SWIG_PY_STRING:
47096 if (constants[i].pvalue) {
47097 obj = PyString_FromString((char *) constants[i].pvalue);
47098 } else {
47099 Py_INCREF(Py_None);
47100 obj = Py_None;
47101 }
47102 break;
47103 case SWIG_PY_POINTER:
47104 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47105 break;
47106 case SWIG_PY_BINARY:
47107 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47108 break;
47109 default:
47110 obj = 0;
47111 break;
47112 }
47113 if (obj) {
47114 PyDict_SetItemString(d,constants[i].name,obj);
47115 Py_DECREF(obj);
47116 }
47117 }
47118 }
47119
47120 /* -----------------------------------------------------------------------------*/
47121 /* Fix SwigMethods to carry the callback ptrs when needed */
47122 /* -----------------------------------------------------------------------------*/
47123
47124 static void
47125 SWIG_Python_FixMethods(PyMethodDef *methods,
47126 swig_const_info *const_table,
47127 swig_type_info **types,
47128 swig_type_info **types_initial) {
47129 size_t i;
47130 for (i = 0; methods[i].ml_name; ++i) {
47131 char *c = methods[i].ml_doc;
47132 if (c && (c = strstr(c, "swig_ptr: "))) {
47133 int j;
47134 swig_const_info *ci = 0;
47135 char *name = c + 10;
47136 for (j = 0; const_table[j].type; j++) {
47137 if (strncmp(const_table[j].name, name,
47138 strlen(const_table[j].name)) == 0) {
47139 ci = &(const_table[j]);
47140 break;
47141 }
47142 }
47143 if (ci) {
47144 size_t shift = (ci->ptype) - types;
47145 swig_type_info *ty = types_initial[shift];
47146 size_t ldoc = (c - methods[i].ml_doc);
47147 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47148 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47149 char *buff = ndoc;
47150 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47151 strncpy(buff, methods[i].ml_doc, ldoc);
47152 buff += ldoc;
47153 strncpy(buff, "swig_ptr: ", 10);
47154 buff += 10;
47155 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47156 methods[i].ml_doc = ndoc;
47157 }
47158 }
47159 }
47160 }
47161
47162 /* -----------------------------------------------------------------------------*
47163 * Initialize type list
47164 * -----------------------------------------------------------------------------*/
47165
47166 #if PY_MAJOR_VERSION < 2
47167 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47168 is copied out of Python/modsupport.c in python version 2.3.4 */
47169 static int
47170 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47171 {
47172 PyObject *dict;
47173 if (!PyModule_Check(m)) {
47174 PyErr_SetString(PyExc_TypeError,
47175 "PyModule_AddObject() needs module as first arg");
47176 return -1;
47177 }
47178 if (!o) {
47179 PyErr_SetString(PyExc_TypeError,
47180 "PyModule_AddObject() needs non-NULL value");
47181 return -1;
47182 }
47183
47184 dict = PyModule_GetDict(m);
47185 if (dict == NULL) {
47186 /* Internal error -- modules must have a dict! */
47187 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47188 PyModule_GetName(m));
47189 return -1;
47190 }
47191 if (PyDict_SetItemString(dict, name, o))
47192 return -1;
47193 Py_DECREF(o);
47194 return 0;
47195 }
47196 #endif
47197
47198 static swig_type_info **
47199 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47200 static PyMethodDef swig_empty_runtime_method_table[] = {
47201 {
47202 NULL, NULL, 0, NULL
47203 }
47204 };/* Sentinel */
47205
47206 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47207 swig_empty_runtime_method_table);
47208 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47209 if (pointer && module) {
47210 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47211 }
47212 return type_list_handle;
47213 }
47214
47215 static swig_type_info **
47216 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47217 swig_type_info **type_pointer;
47218
47219 /* first check if module already created */
47220 type_pointer = SWIG_Python_GetTypeListHandle();
47221 if (type_pointer) {
47222 return type_pointer;
47223 } else {
47224 /* create a new module and variable */
47225 return SWIG_Python_SetTypeListHandle(type_list_handle);
47226 }
47227 }
47228
47229 #ifdef __cplusplus
47230 }
47231 #endif
47232
47233 /* -----------------------------------------------------------------------------*
47234 * Partial Init method
47235 * -----------------------------------------------------------------------------*/
47236
47237 #ifdef SWIG_LINK_RUNTIME
47238 #ifdef __cplusplus
47239 extern "C"
47240 #endif
47241 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47242 #endif
47243
47244 #ifdef __cplusplus
47245 extern "C"
47246 #endif
47247 SWIGEXPORT(void) SWIG_init(void) {
47248 static PyObject *SWIG_globals = 0;
47249 static int typeinit = 0;
47250 PyObject *m, *d;
47251 int i;
47252 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47253
47254 /* Fix SwigMethods to carry the callback ptrs when needed */
47255 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47256
47257 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47258 d = PyModule_GetDict(m);
47259
47260 if (!typeinit) {
47261 #ifdef SWIG_LINK_RUNTIME
47262 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47263 #else
47264 # ifndef SWIG_STATIC_RUNTIME
47265 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47266 # endif
47267 #endif
47268 for (i = 0; swig_types_initial[i]; i++) {
47269 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47270 }
47271 typeinit = 1;
47272 }
47273 SWIG_InstallConstants(d,swig_const_table);
47274
47275
47276 #ifndef wxPyUSE_EXPORT
47277 // Make our API structure a CObject so other modules can import it
47278 // from this module.
47279 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47280 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47281 Py_XDECREF(cobj);
47282 #endif
47283
47284 {
47285 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48888 }
48889 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48890 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48891 {
48892 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49043 }
49044 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49045 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49046 {
49047 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49054 }
49055
49056 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49057
49058
49059 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49060
49061 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49062 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49063 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49064 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49065 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49066 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49067 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49068 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49069 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49070 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49071 {
49072 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49076 }
49077 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49078 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49079 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49080 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49081 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49082 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49083 {
49084 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49118 }
49119 {
49120 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49121 }
49122 {
49123 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49124 }
49125 {
49126 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49127 }
49128 {
49129 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49130 }
49131 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49132 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49133 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49134 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49135 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49136 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49137 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49138 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49139 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49140 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49141 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49142 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49143 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49144 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49145 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49146 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49147 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49148 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49149 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49150 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49151 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49152 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49153 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49154 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49155 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49156 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49157 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49158 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49159 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49160 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49161 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49162 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49163 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49164 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49165 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49166 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49167 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49168 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49169 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49170 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49171 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49172 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49173 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49174 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49175 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49176 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49177 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49178 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49179 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49180 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49181 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49182 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49183 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49184 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49185 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49186 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49187 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49188 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49189 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49190 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49191 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49192 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49193 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49194 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49195 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49196 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49197 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49198 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49199 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49200 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49201 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49202 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49203 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49204 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49205 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49206 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49207 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49208 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49209 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49210 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49211 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49212 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49213 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49214 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49215 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49216 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49217 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49218 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49219 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49220 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49221 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49222 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49223 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49224 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49225 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49226 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49227 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49228 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49229 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49230 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49231 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49232 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49233 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49234 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49235 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49236 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49237 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49238 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49239 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49240 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49241 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49242 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49243 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49244 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49245 {
49246 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49283 }
49284 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49285 {
49286 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49302 }
49303 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49304 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49305 {
49306 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49319 }
49320 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49321 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49322 {
49323 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49330 }
49331 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49332 {
49333 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49388 }
49389
49390 // Initialize threading, some globals and such
49391 __wxPyPreStart(d);
49392
49393
49394 // Although these are defined in __version__ they need to be here too so
49395 // that an assert can be done to ensure that the wxPython and the wxWindows
49396 // versions match.
49397 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49398 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49399 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49400
49401 }
49402
wxWidgets (Impactor)