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


ec26a8c32f93075864da174766139b1ae492157e
[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.29
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 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutDirection swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRegion swig_types[110]
2577 #define SWIGTYPE_p_wxScrollEvent swig_types[111]
2578 #define SWIGTYPE_p_wxScrollWinEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSetCursorEvent swig_types[113]
2580 #define SWIGTYPE_p_wxShowEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSize swig_types[115]
2582 #define SWIGTYPE_p_wxSizeEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSizer swig_types[117]
2584 #define SWIGTYPE_p_wxSizerItem swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBox swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[121]
2588 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[122]
2589 #define SWIGTYPE_p_wxTIFFHandler swig_types[123]
2590 #define SWIGTYPE_p_wxToolTip swig_types[124]
2591 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[125]
2592 #define SWIGTYPE_p_wxValidator swig_types[126]
2593 #define SWIGTYPE_p_wxVisualAttributes swig_types[127]
2594 #define SWIGTYPE_p_wxWindow swig_types[128]
2595 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[129]
2596 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[130]
2597 #define SWIGTYPE_p_wxXPMHandler swig_types[131]
2598 #define SWIGTYPE_p_wxZipFSHandler swig_types[132]
2599 static swig_type_info *swig_types[134];
2600 static swig_module_info swig_module = {swig_types, 133, 0, 0, 0, 0};
2601 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2602 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2603
2604 /* -------- TYPES TABLE (END) -------- */
2605
2606 #if (PY_VERSION_HEX <= 0x02000000)
2607 # if !defined(SWIG_PYTHON_CLASSIC)
2608 # error "This python version requires to use swig with the '-classic' option"
2609 # endif
2610 #endif
2611 #if (PY_VERSION_HEX <= 0x02020000)
2612 # error "This python version requires to use swig with the '-nomodern' option"
2613 #endif
2614 #if (PY_VERSION_HEX <= 0x02020000)
2615 # error "This python version requires to use swig with the '-nomodernargs' option"
2616 #endif
2617 #ifndef METH_O
2618 # error "This python version requires to use swig with the '-nofastunpack' option"
2619 #endif
2620
2621 /*-----------------------------------------------
2622 @(target):= _core_.so
2623 ------------------------------------------------*/
2624 #define SWIG_init init_core_
2625
2626 #define SWIG_name "_core_"
2627
2628 #define SWIGVERSION 0x010329
2629
2630
2631 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2632 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2633
2634
2635 #include <stdexcept>
2636
2637
2638 namespace swig {
2639 class PyObject_ptr {
2640 protected:
2641 PyObject *_obj;
2642
2643 public:
2644 PyObject_ptr() :_obj(0)
2645 {
2646 }
2647
2648 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2649 {
2650 Py_XINCREF(_obj);
2651 }
2652
2653 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2654 {
2655 if (initial_ref) Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr & operator=(const PyObject_ptr& item)
2659 {
2660 Py_XINCREF(item._obj);
2661 Py_XDECREF(_obj);
2662 _obj = item._obj;
2663 return *this;
2664 }
2665
2666 ~PyObject_ptr()
2667 {
2668 Py_XDECREF(_obj);
2669 }
2670
2671 operator PyObject *() const
2672 {
2673 return _obj;
2674 }
2675
2676 PyObject *operator->() const
2677 {
2678 return _obj;
2679 }
2680 };
2681 }
2682
2683
2684 namespace swig {
2685 struct PyObject_var : PyObject_ptr {
2686 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2687
2688 PyObject_var & operator = (PyObject* obj)
2689 {
2690 Py_XDECREF(_obj);
2691 _obj = obj;
2692 return *this;
2693 }
2694 };
2695 }
2696
2697
2698 #include "wx/wxPython/wxPython_int.h"
2699 #include "wx/wxPython/pyclasses.h"
2700 #include "wx/wxPython/twoitem.h"
2701
2702
2703 #ifndef wxPyUSE_EXPORT
2704 // Helper functions for dealing with SWIG objects and such. These are
2705 // located here so they know about the SWIG types and functions declared
2706 // in the wrapper code.
2707
2708 #include <wx/hashmap.h>
2709 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2710
2711
2712 // Maintains a hashmap of className to swig_type_info pointers. Given the
2713 // name of a class either looks up the type info in the cache, or scans the
2714 // SWIG tables for it.
2715 extern PyObject* wxPyPtrTypeMap;
2716 static
2717 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2718
2719 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2720
2721 if (typeInfoCache == NULL)
2722 typeInfoCache = new wxPyTypeInfoHashMap;
2723
2724 wxString name(className);
2725 swig_type_info* swigType = (*typeInfoCache)[name];
2726
2727 if (! swigType) {
2728 // it wasn't in the cache, so look it up from SWIG
2729 name.Append(wxT(" *"));
2730 swigType = SWIG_TypeQuery(name.mb_str());
2731
2732 // if it still wasn't found, try looking for a mapped name
2733 if (!swigType) {
2734 PyObject* item;
2735 name = className;
2736
2737 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2738 (char*)(const char*)name.mbc_str())) != NULL) {
2739 name = wxString(PyString_AsString(item), *wxConvCurrent);
2740 name.Append(wxT(" *"));
2741 swigType = SWIG_TypeQuery(name.mb_str());
2742 }
2743 }
2744 if (swigType) {
2745 // and add it to the map if found
2746 (*typeInfoCache)[className] = swigType;
2747 }
2748 }
2749 return swigType;
2750 }
2751
2752
2753 // Check if a class name is a type known to SWIG
2754 bool wxPyCheckSwigType(const wxChar* className) {
2755
2756 swig_type_info* swigType = wxPyFindSwigType(className);
2757 return swigType != NULL;
2758 }
2759
2760
2761 // Given a pointer to a C++ object and a class name, construct a Python proxy
2762 // object for it.
2763 PyObject* wxPyConstructObject(void* ptr,
2764 const wxChar* className,
2765 int setThisOwn) {
2766
2767 swig_type_info* swigType = wxPyFindSwigType(className);
2768 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2769
2770 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2771 }
2772
2773
2774 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2775 // Ensures that the proxy object is of the specified (or derived) type. If
2776 // not able to perform the conversion then a Python exception is set and the
2777 // error should be handled properly in the caller. Returns True on success.
2778 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2779 const wxChar* className) {
2780
2781 swig_type_info* swigType = wxPyFindSwigType(className);
2782 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2783
2784 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2785 }
2786
2787
2788
2789 // Make a SWIGified pointer object suitable for a .this attribute
2790 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2791
2792 PyObject* robj = NULL;
2793
2794 swig_type_info* swigType = wxPyFindSwigType(className);
2795 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2796
2797 robj = PySwigObject_New(ptr, swigType, 0);
2798 return robj;
2799 }
2800
2801
2802 // Python's PyInstance_Check does not return True for instances of new-style
2803 // classes. This should get close enough for both new and old classes but I
2804 // should re-evaluate the need for doing instance checks...
2805 bool wxPyInstance_Check(PyObject* obj) {
2806 return PyObject_HasAttrString(obj, "__class__") != 0;
2807 }
2808
2809
2810 // This one checks if the object is an instance of a SWIG proxy class (it has
2811 // a .this attribute, and the .this attribute is a PySwigObject.)
2812 bool wxPySwigInstance_Check(PyObject* obj) {
2813 static PyObject* this_str = NULL;
2814 if (this_str == NULL)
2815 this_str = PyString_FromString("this");
2816
2817 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2818 if (this_attr) {
2819 bool retval = (PySwigObject_Check(this_attr) != 0);
2820 Py_DECREF(this_attr);
2821 return retval;
2822 }
2823
2824 PyErr_Clear();
2825 return false;
2826 }
2827
2828
2829 // Export a C API in a struct. Other modules will be able to load this from
2830 // the wx._core_ module and will then have safe access to these functions,
2831 // even if they are located in another shared library.
2832 static wxPyCoreAPI API = {
2833
2834 wxPyCheckSwigType,
2835 wxPyConstructObject,
2836 wxPyConvertSwigPtr,
2837 wxPyMakeSwigPtr,
2838
2839 wxPyBeginAllowThreads,
2840 wxPyEndAllowThreads,
2841 wxPyBeginBlockThreads,
2842 wxPyEndBlockThreads,
2843
2844 wxPy_ConvertList,
2845
2846 wxString_in_helper,
2847 Py2wxString,
2848 wx2PyString,
2849
2850 byte_LIST_helper,
2851 int_LIST_helper,
2852 long_LIST_helper,
2853 string_LIST_helper,
2854 wxPoint_LIST_helper,
2855 wxBitmap_LIST_helper,
2856 wxString_LIST_helper,
2857 wxAcceleratorEntry_LIST_helper,
2858
2859 wxSize_helper,
2860 wxPoint_helper,
2861 wxRealPoint_helper,
2862 wxRect_helper,
2863 wxColour_helper,
2864 wxPoint2D_helper,
2865
2866 wxPySimple_typecheck,
2867 wxColour_typecheck,
2868
2869 wxPyCBH_setCallbackInfo,
2870 wxPyCBH_findCallback,
2871 wxPyCBH_callCallback,
2872 wxPyCBH_callCallbackObj,
2873 wxPyCBH_delete,
2874
2875 wxPyMake_wxObject,
2876 wxPyMake_wxSizer,
2877 wxPyPtrTypeMap_Add,
2878 wxPy2int_seq_helper,
2879 wxPy4int_seq_helper,
2880 wxArrayString2PyList_helper,
2881 wxArrayInt2PyList_helper,
2882
2883 wxPyClientData_dtor,
2884 wxPyUserData_dtor,
2885 wxPyOORClientData_dtor,
2886
2887 wxPyCBInputStream_create,
2888 wxPyCBInputStream_copy,
2889
2890 wxPyInstance_Check,
2891 wxPySwigInstance_Check,
2892
2893 wxPyCheckForApp
2894
2895 };
2896
2897 #endif
2898
2899
2900 #if !WXWIN_COMPATIBILITY_2_4
2901 #define wxHIDE_READONLY 0
2902 #endif
2903
2904
2905 #define SWIG_From_long PyInt_FromLong
2906
2907
2908 SWIGINTERNINLINE PyObject *
2909 SWIG_From_int (int value)
2910 {
2911 return SWIG_From_long (value);
2912 }
2913
2914 static const wxString wxPyEmptyString(wxEmptyString);
2915 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2916 return self->GetClassInfo()->GetClassName();
2917 }
2918 SWIGINTERN void wxObject_Destroy(wxObject *self){
2919 delete self;
2920 }
2921
2922 #ifndef __WXMAC__
2923 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2924 #endif
2925
2926
2927 #include <limits.h>
2928 #ifndef LLONG_MIN
2929 # define LLONG_MIN LONG_LONG_MIN
2930 #endif
2931 #ifndef LLONG_MAX
2932 # define LLONG_MAX LONG_LONG_MAX
2933 #endif
2934 #ifndef ULLONG_MAX
2935 # define ULLONG_MAX ULONG_LONG_MAX
2936 #endif
2937
2938
2939 SWIGINTERN int
2940 SWIG_AsVal_long (PyObject* obj, long* val)
2941 {
2942 if (PyNumber_Check(obj)) {
2943 if (val) *val = PyInt_AsLong(obj);
2944 return SWIG_OK;
2945 }
2946 return SWIG_TypeError;
2947 }
2948
2949
2950 SWIGINTERN int
2951 SWIG_AsVal_int (PyObject * obj, int *val)
2952 {
2953 long v;
2954 int res = SWIG_AsVal_long (obj, &v);
2955 if (SWIG_IsOK(res)) {
2956 if ((v < INT_MIN || v > INT_MAX)) {
2957 return SWIG_OverflowError;
2958 } else {
2959 if (val) *val = static_cast< int >(v);
2960 }
2961 }
2962 return res;
2963 }
2964
2965 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return false;
2968 if ( ! wxSize_helper(other, &obj) ) {
2969 PyErr_Clear();
2970 return false;
2971 }
2972 return self->operator==(*obj);
2973 }
2974 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2975 wxSize temp, *obj = &temp;
2976 if ( other == Py_None ) return true;
2977 if ( ! wxSize_helper(other, &obj)) {
2978 PyErr_Clear();
2979 return true;
2980 }
2981 return self->operator!=(*obj);
2982 }
2983
2984 #include <float.h>
2985
2986
2987 SWIGINTERN int
2988 SWIG_AsVal_double (PyObject *obj, double* val)
2989 {
2990 if (PyNumber_Check(obj)) {
2991 if (val) *val = PyFloat_AsDouble(obj);
2992 return SWIG_OK;
2993 }
2994 return SWIG_TypeError;
2995 }
2996
2997
2998 SWIGINTERN int
2999 SWIG_AsVal_float (PyObject * obj, float *val)
3000 {
3001 double v;
3002 int res = SWIG_AsVal_double (obj, &v);
3003 if (SWIG_IsOK(res)) {
3004 if ((v < -FLT_MAX || v > FLT_MAX)) {
3005 return SWIG_OverflowError;
3006 } else {
3007 if (val) *val = static_cast< float >(v);
3008 }
3009 }
3010 return res;
3011 }
3012
3013 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3015 PyObject* tup = PyTuple_New(2);
3016 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3017 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3018 wxPyEndBlockThreads(blocked);
3019 return tup;
3020 }
3021
3022 #define SWIG_From_double PyFloat_FromDouble
3023
3024 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3025 wxRealPoint temp, *obj = &temp;
3026 if ( other == Py_None ) return false;
3027 if ( ! wxRealPoint_helper(other, &obj) ) {
3028 PyErr_Clear();
3029 return false;
3030 }
3031 return self->operator==(*obj);
3032 }
3033 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3034 wxRealPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return true;
3036 if ( ! wxRealPoint_helper(other, &obj)) {
3037 PyErr_Clear();
3038 return true;
3039 }
3040 return self->operator!=(*obj);
3041 }
3042 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3043 self->x = x;
3044 self->y = y;
3045 }
3046 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3047 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3048 PyObject* tup = PyTuple_New(2);
3049 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3050 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3051 wxPyEndBlockThreads(blocked);
3052 return tup;
3053 }
3054 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3055 wxPoint temp, *obj = &temp;
3056 if ( other == Py_None ) return false;
3057 if ( ! wxPoint_helper(other, &obj) ) {
3058 PyErr_Clear();
3059 return false;
3060 }
3061 return self->operator==(*obj);
3062 }
3063 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3064 wxPoint temp, *obj = &temp;
3065 if ( other == Py_None ) return true;
3066 if ( ! wxPoint_helper(other, &obj)) {
3067 PyErr_Clear();
3068 return true;
3069 }
3070 return self->operator!=(*obj);
3071 }
3072 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3073 self->x = x;
3074 self->y = y;
3075 }
3076 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 PyObject* tup = PyTuple_New(2);
3079 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3080 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3081 wxPyEndBlockThreads(blocked);
3082 return tup;
3083 }
3084 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3085 wxRect temp, *obj = &temp;
3086 if ( other == Py_None ) return false;
3087 if ( ! wxRect_helper(other, &obj) ) {
3088 PyErr_Clear();
3089 return false;
3090 }
3091 return self->operator==(*obj);
3092 }
3093 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3094 wxRect temp, *obj = &temp;
3095 if ( other == Py_None ) return true;
3096 if ( ! wxRect_helper(other, &obj)) {
3097 PyErr_Clear();
3098 return true;
3099 }
3100 return self->operator!=(*obj);
3101 }
3102 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3103 self->x = x;
3104 self->y = y;
3105 self->width = width;
3106 self->height = height;
3107 }
3108 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3110 PyObject* tup = PyTuple_New(4);
3111 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3112 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3113 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3114 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3115 wxPyEndBlockThreads(blocked);
3116 return tup;
3117 }
3118
3119 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3120 wxRegion reg1(*r1);
3121 wxRegion reg2(*r2);
3122 wxRect dest(0,0,0,0);
3123 PyObject* obj;
3124
3125 reg1.Intersect(reg2);
3126 dest = reg1.GetBox();
3127
3128 if (dest != wxRect(0,0,0,0)) {
3129 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3130 wxRect* newRect = new wxRect(dest);
3131 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3132 wxPyEndBlockThreads(blocked);
3133 return obj;
3134 }
3135 Py_INCREF(Py_None);
3136 return Py_None;
3137 }
3138
3139 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3140 wxPoint2D temp, *obj = &temp;
3141 if ( other == Py_None ) return false;
3142 if ( ! wxPoint2D_helper(other, &obj) ) {
3143 PyErr_Clear();
3144 return false;
3145 }
3146 return self->operator==(*obj);
3147 }
3148 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3149 wxPoint2D temp, *obj = &temp;
3150 if ( other == Py_None ) return true;
3151 if ( ! wxPoint2D_helper(other, &obj)) {
3152 PyErr_Clear();
3153 return true;
3154 }
3155 return self->operator!=(*obj);
3156 }
3157 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3158 self->m_x = x;
3159 self->m_y = y;
3160 }
3161 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3163 PyObject* tup = PyTuple_New(2);
3164 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3165 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3166 wxPyEndBlockThreads(blocked);
3167 return tup;
3168 }
3169
3170 #include "wx/wxPython/pyistream.h"
3171
3172 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3173 wxInputStream* wxis = wxPyCBInputStream::create(p);
3174 if (wxis)
3175 return new wxPyInputStream(wxis);
3176 else
3177 return NULL;
3178 }
3179
3180 SWIGINTERN swig_type_info*
3181 SWIG_pchar_descriptor()
3182 {
3183 static int init = 0;
3184 static swig_type_info* info = 0;
3185 if (!init) {
3186 info = SWIG_TypeQuery("_p_char");
3187 init = 1;
3188 }
3189 return info;
3190 }
3191
3192
3193 SWIGINTERNINLINE PyObject *
3194 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3195 {
3196 if (carray) {
3197 if (size > INT_MAX) {
3198 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3199 return pchar_descriptor ?
3200 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3201 } else {
3202 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3203 }
3204 } else {
3205 return SWIG_Py_Void();
3206 }
3207 }
3208
3209
3210 SWIGINTERNINLINE PyObject *
3211 SWIG_From_char (char c)
3212 {
3213 return SWIG_FromCharPtrAndSize(&c,1);
3214 }
3215
3216
3217 SWIGINTERNINLINE PyObject*
3218 SWIG_From_unsigned_SS_long (unsigned long value)
3219 {
3220 return (value > LONG_MAX) ?
3221 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3222 }
3223
3224
3225 SWIGINTERNINLINE PyObject *
3226 SWIG_From_size_t (size_t value)
3227 {
3228 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3229 }
3230
3231
3232 SWIGINTERN int
3233 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3234 {
3235 if (PyString_Check(obj)) {
3236 char *cstr; Py_ssize_t len;
3237 PyString_AsStringAndSize(obj, &cstr, &len);
3238 if (cptr) {
3239 if (alloc) {
3240 /*
3241 In python the user should not be able to modify the inner
3242 string representation. To warranty that, if you define
3243 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3244 buffer is always returned.
3245
3246 The default behavior is just to return the pointer value,
3247 so, be careful.
3248 */
3249 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3250 if (*alloc != SWIG_OLDOBJ)
3251 #else
3252 if (*alloc == SWIG_NEWOBJ)
3253 #endif
3254 {
3255 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3256 *alloc = SWIG_NEWOBJ;
3257 }
3258 else {
3259 *cptr = cstr;
3260 *alloc = SWIG_OLDOBJ;
3261 }
3262 } else {
3263 *cptr = PyString_AsString(obj);
3264 }
3265 }
3266 if (psize) *psize = len + 1;
3267 return SWIG_OK;
3268 } else {
3269 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3270 if (pchar_descriptor) {
3271 void* vptr = 0;
3272 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3273 if (cptr) *cptr = (char *) vptr;
3274 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3275 if (alloc) *alloc = SWIG_OLDOBJ;
3276 return SWIG_OK;
3277 }
3278 }
3279 }
3280 return SWIG_TypeError;
3281 }
3282
3283
3284 SWIGINTERN int
3285 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3286 {
3287 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3288 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3289 if (SWIG_IsOK(res)) {
3290 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3291 if (csize <= size) {
3292 if (val) {
3293 if (csize) memcpy(val, cptr, csize*sizeof(char));
3294 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3295 }
3296 if (alloc == SWIG_NEWOBJ) {
3297 delete[] cptr;
3298 res = SWIG_DelNewMask(res);
3299 }
3300 return res;
3301 }
3302 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3303 }
3304 return SWIG_TypeError;
3305 }
3306
3307
3308 SWIGINTERN int
3309 SWIG_AsVal_char (PyObject * obj, char *val)
3310 {
3311 int res = SWIG_AsCharArray(obj, val, 1);
3312 if (!SWIG_IsOK(res)) {
3313 long v;
3314 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3315 if (SWIG_IsOK(res)) {
3316 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3317 if (val) *val = static_cast< char >(v);
3318 } else {
3319 res = SWIG_OverflowError;
3320 }
3321 }
3322 }
3323 return res;
3324 }
3325
3326 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3327 // We use only strings for the streams, not unicode
3328 PyObject* str = PyObject_Str(obj);
3329 if (! str) {
3330 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3331 return;
3332 }
3333 self->Write(PyString_AS_STRING(str),
3334 PyString_GET_SIZE(str));
3335 Py_DECREF(str);
3336 }
3337
3338 #include "wx/wxPython/pyistream.h"
3339
3340
3341 class wxPyFileSystemHandler : public wxFileSystemHandler
3342 {
3343 public:
3344 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3345
3346 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3347 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3348 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3349 DEC_PYCALLBACK_STRING__pure(FindNext);
3350
3351 wxString GetProtocol(const wxString& location) {
3352 return wxFileSystemHandler::GetProtocol(location);
3353 }
3354
3355 wxString GetLeftLocation(const wxString& location) {
3356 return wxFileSystemHandler::GetLeftLocation(location);
3357 }
3358
3359 wxString GetAnchor(const wxString& location) {
3360 return wxFileSystemHandler::GetAnchor(location);
3361 }
3362
3363 wxString GetRightLocation(const wxString& location) {
3364 return wxFileSystemHandler::GetRightLocation(location);
3365 }
3366
3367 wxString GetMimeTypeFromExt(const wxString& location) {
3368 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3369 }
3370
3371 PYPRIVATE;
3372 };
3373
3374
3375 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3376 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3377 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3378 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3379
3380
3381 SWIGINTERN int
3382 SWIG_AsVal_bool (PyObject *obj, bool *val)
3383 {
3384 if (obj == Py_True) {
3385 if (val) *val = true;
3386 return SWIG_OK;
3387 } else if (obj == Py_False) {
3388 if (val) *val = false;
3389 return SWIG_OK;
3390 } else {
3391 long v = 0;
3392 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3393 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3394 return res;
3395 }
3396 }
3397
3398 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3399 wxFileName fname = wxFileSystem::URLToFileName(url);
3400 return fname.GetFullPath();
3401 }
3402
3403 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3404 wxImage& image,
3405 long type) {
3406 wxMemoryFSHandler::AddFile(filename, image, type);
3407 }
3408
3409 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3410 const wxBitmap& bitmap,
3411 long type) {
3412 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3413 }
3414
3415 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3416 PyObject* data) {
3417 if (! PyString_Check(data)) {
3418 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3419 "Expected string object"));
3420 return;
3421 }
3422
3423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3424 void* ptr = (void*)PyString_AsString(data);
3425 size_t size = PyString_Size(data);
3426 wxPyEndBlockThreads(blocked);
3427
3428 wxMemoryFSHandler::AddFile(filename, ptr, size);
3429 }
3430
3431
3432 #include "wx/wxPython/pyistream.h"
3433
3434
3435 SWIGINTERN int
3436 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3437 {
3438 long v = 0;
3439 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3440 return SWIG_TypeError;
3441 }
3442 else if (val)
3443 *val = (unsigned long)v;
3444 return SWIG_OK;
3445 }
3446
3447
3448 SWIGINTERN int
3449 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3450 {
3451 unsigned long v;
3452 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3453 if (SWIG_IsOK(res)) {
3454 if ((v > UCHAR_MAX)) {
3455 return SWIG_OverflowError;
3456 } else {
3457 if (val) *val = static_cast< unsigned char >(v);
3458 }
3459 }
3460 return res;
3461 }
3462
3463
3464 SWIGINTERNINLINE PyObject *
3465 SWIG_From_unsigned_SS_char (unsigned char value)
3466 {
3467 return SWIG_From_unsigned_SS_long (value);
3468 }
3469
3470 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3471 wxImageHistogramEntry e = (*self)[key];
3472 return e.value;
3473 }
3474 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3475 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3476 wxImageHistogramEntry e = (*self)[key];
3477 return e.value;
3478 }
3479 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3480 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3481 colour.Green(),
3482 colour.Blue());
3483 wxImageHistogramEntry e = (*self)[key];
3484 return e.value;
3485 }
3486
3487 // Pull the nested class out to the top level for SWIG's sake
3488 #define wxImage_RGBValue wxImage::RGBValue
3489 #define wxImage_HSVValue wxImage::HSVValue
3490
3491 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3492 if (width > 0 && height > 0)
3493 return new wxImage(width, height, clear);
3494 else
3495 return new wxImage;
3496 }
3497 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3498 return new wxImage(bitmap.ConvertToImage());
3499 }
3500 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3501 if (DATASIZE != width*height*3) {
3502 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3503 return NULL;
3504 }
3505
3506 // Copy the source data so the wxImage can clean it up later
3507 buffer copy = (buffer)malloc(DATASIZE);
3508 if (copy == NULL) {
3509 wxPyBLOCK_THREADS(PyErr_NoMemory());
3510 return NULL;
3511 }
3512 memcpy(copy, data, DATASIZE);
3513 return new wxImage(width, height, copy, false);
3514 }
3515 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3516 if (DATASIZE != width*height*3) {
3517 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3518 return NULL;
3519 }
3520 if (ALPHASIZE != width*height) {
3521 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3522 return NULL;
3523 }
3524
3525 // Copy the source data so the wxImage can clean it up later
3526 buffer dcopy = (buffer)malloc(DATASIZE);
3527 if (dcopy == NULL) {
3528 wxPyBLOCK_THREADS(PyErr_NoMemory());
3529 return NULL;
3530 }
3531 memcpy(dcopy, data, DATASIZE);
3532
3533 buffer acopy = (buffer)malloc(ALPHASIZE);
3534 if (acopy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return NULL;
3537 }
3538 memcpy(acopy, alpha, ALPHASIZE);
3539
3540 return new wxImage(width, height, dcopy, acopy, false);
3541 }
3542 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3543 wxSize size(self->GetWidth(), self->GetHeight());
3544 return size;
3545 }
3546 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3547 buffer data = self->GetData();
3548 int len = self->GetWidth() * self->GetHeight() * 3;
3549 PyObject* rv;
3550 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3551 return rv;
3552 }
3553 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3554 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3555 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3556 return;
3557 }
3558 buffer copy = (buffer)malloc(DATASIZE);
3559 if (copy == NULL) {
3560 wxPyBLOCK_THREADS(PyErr_NoMemory());
3561 return;
3562 }
3563 memcpy(copy, data, DATASIZE);
3564 self->SetData(copy, false);
3565 // wxImage takes ownership of copy...
3566 }
3567 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3568 buffer data = self->GetData();
3569 int len = self->GetWidth() * self->GetHeight() * 3;
3570 PyObject* rv;
3571 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3572 return rv;
3573 }
3574 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3575 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3577 return;
3578 }
3579 self->SetData(data, true);
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 if (! data) {
3584 RETURN_NONE();
3585 } else {
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3589 return rv;
3590 }
3591 }
3592 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3593 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3595 return;
3596 }
3597 buffer acopy = (buffer)malloc(ALPHASIZE);
3598 if (acopy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(acopy, alpha, ALPHASIZE);
3603 self->SetAlpha(acopy, false);
3604 // wxImage takes ownership of acopy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3607 buffer data = self->GetAlpha();
3608 int len = self->GetWidth() * self->GetHeight();
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3614 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3616 return;
3617 }
3618 self->SetAlpha(alpha, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetHandlers(){
3621 wxList& list = wxImage::GetHandlers();
3622 return wxPy_ConvertList(&list);
3623 }
3624 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3625 wxBitmap bitmap(*self, depth);
3626 return bitmap;
3627 }
3628 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3629 wxImage mono = self->ConvertToMono( red, green, blue );
3630 wxBitmap bitmap( mono, 1 );
3631 return bitmap;
3632 }
3633
3634 wxImage* _ImageFromBuffer(int width, int height,
3635 buffer data, int DATASIZE,
3636 buffer alpha=NULL, int ALPHASIZE=0)
3637 {
3638 if (DATASIZE != width*height*3) {
3639 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3640 return NULL;
3641 }
3642 if (alpha != NULL) {
3643 if (ALPHASIZE != width*height) {
3644 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3645 return NULL;
3646 }
3647 return new wxImage(width, height, data, alpha, true);
3648 }
3649 return new wxImage(width, height, data, true);
3650 }
3651
3652 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3653 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3660 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3661 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3662 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3663 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3664 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3665 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3666 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3667
3668 #include <wx/quantize.h>
3669
3670 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3671 return wxQuantize::Quantize(src, dest,
3672 //NULL, // palette
3673 desiredNoColours,
3674 NULL, // eightBitData
3675 flags);
3676 }
3677 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3678 if (PyCallable_Check(func)) {
3679 self->Connect(id, lastId, eventType,
3680 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3681 new wxPyCallback(func));
3682 }
3683 else if (func == Py_None) {
3684 self->Disconnect(id, lastId, eventType,
3685 (wxObjectEventFunction)
3686 &wxPyCallback::EventThunker);
3687 }
3688 else {
3689 wxPyBLOCK_THREADS(
3690 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3691 }
3692 }
3693 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3694 return self->Disconnect(id, lastId, eventType,
3695 (wxObjectEventFunction)
3696 &wxPyCallback::EventThunker);
3697 }
3698 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3699 if (_self && _self != Py_None) {
3700 self->SetClientObject(new wxPyOORClientData(_self, incref));
3701 }
3702 else {
3703 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3704 if (data) {
3705 self->SetClientObject(NULL); // This will delete it too
3706 }
3707 }
3708 }
3709
3710 #if ! wxUSE_HOTKEY
3711 #define wxEVT_HOTKEY -9999
3712 #endif
3713
3714 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3715 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3716 if (data) {
3717 Py_INCREF(data->m_obj);
3718 return data->m_obj;
3719 } else {
3720 Py_INCREF(Py_None);
3721 return Py_None;
3722 }
3723 }
3724 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3725 wxPyClientData* data = new wxPyClientData(clientData);
3726 self->SetClientObject(data);
3727 }
3728 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3729 #if wxUSE_UNICODE
3730 return self->GetUnicodeKey();
3731 #else
3732 return 0;
3733 #endif
3734 }
3735 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3736 #if wxUSE_UNICODE
3737 self->m_uniChar = uniChar;
3738 #endif
3739 }
3740
3741 SWIGINTERNINLINE PyObject *
3742 SWIG_From_unsigned_SS_int (unsigned int value)
3743 {
3744 return SWIG_From_unsigned_SS_long (value);
3745 }
3746
3747
3748 SWIGINTERN int
3749 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3750 {
3751 unsigned long v;
3752 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3753 if (SWIG_IsOK(res)) {
3754 if ((v > UINT_MAX)) {
3755 return SWIG_OverflowError;
3756 } else {
3757 if (val) *val = static_cast< unsigned int >(v);
3758 }
3759 }
3760 return res;
3761 }
3762
3763 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3764 self->m_size = size;
3765 }
3766 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3767 int count = self->GetNumberOfFiles();
3768 wxString* files = self->GetFiles();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 PyObject* list = PyList_New(count);
3771
3772 if (!list) {
3773 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3774 wxPyEndBlockThreads(blocked);
3775 return NULL;
3776 }
3777
3778 for (int i=0; i<count; i++) {
3779 PyList_SetItem(list, i, wx2PyString(files[i]));
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return list;
3783 }
3784
3785
3786 SWIGINTERN wxPyApp *new_wxPyApp(){
3787 wxPythonApp = new wxPyApp();
3788 return wxPythonApp;
3789 }
3790 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3844 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3845 #if wxUSE_HOTKEY
3846 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3847 #else
3848 return false;
3849 #endif
3850 }
3851 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3852
3853
3854
3855 return false;
3856
3857 }
3858 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3859 return wxPyGetWinHandle(self);
3860 }
3861 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3862 self->AssociateHandle((WXWidget)handle);
3863 }
3864
3865 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3866 return wxWindow::FindWindowById(id, parent);
3867 }
3868
3869 wxWindow* wxFindWindowByName( const wxString& name,
3870 const wxWindow *parent = NULL ) {
3871 return wxWindow::FindWindowByName(name, parent);
3872 }
3873
3874 wxWindow* wxFindWindowByLabel( const wxString& label,
3875 const wxWindow *parent = NULL ) {
3876 return wxWindow::FindWindowByLabel(label, parent);
3877 }
3878
3879
3880 #ifdef __WXMSW__
3881 #include <wx/msw/private.h> // to get wxGetWindowId
3882 #endif
3883
3884
3885 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3886 #ifdef __WXMSW__
3887 WXHWND hWnd = (WXHWND)_hWnd;
3888 long id = wxGetWindowId(hWnd);
3889 wxWindow* win = new wxWindow;
3890 if (parent)
3891 parent->AddChild(win);
3892 win->SetEventHandler(win);
3893 win->SetHWND(hWnd);
3894 win->SetId(id);
3895 win->SubclassWin(hWnd);
3896 win->AdoptAttributesFromHWND();
3897 win->SetupColours();
3898 return win;
3899 #else
3900 wxPyRaiseNotImplemented();
3901 return NULL;
3902 #endif
3903 }
3904
3905
3906 PyObject* GetTopLevelWindows() {
3907 return wxPy_ConvertList(&wxTopLevelWindows);
3908 }
3909
3910
3911 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3914
3915 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3916
3917
3918 SWIGINTERNINLINE int
3919 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3920 {
3921 unsigned long v;
3922 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3923 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3924 return res;
3925 }
3926
3927 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3928 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3929 wxMenuItemList& list = self->GetMenuItems();
3930 return wxPy_ConvertList(&list);
3931 }
3932 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3933 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3934 static const wxString wxPyControlNameStr(wxControlNameStr);
3935 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3936 if (clientData) {
3937 wxPyClientData* data = new wxPyClientData(clientData);
3938 return self->Append(item, data);
3939 } else
3940 return self->Append(item);
3941 }
3942 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3943 if (clientData) {
3944 wxPyClientData* data = new wxPyClientData(clientData);
3945 return self->Insert(item, pos, data);
3946 } else
3947 return self->Insert(item, pos);
3948 }
3949 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3950 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3951 if (data) {
3952 Py_INCREF(data->m_obj);
3953 return data->m_obj;
3954 } else {
3955 Py_INCREF(Py_None);
3956 return Py_None;
3957 }
3958 }
3959 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3960 wxPyClientData* data = new wxPyClientData(clientData);
3961 self->SetClientObject(n, data);
3962 }
3963
3964
3965 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3966 wxPyUserData* data = NULL;
3967 if ( userData ) {
3968 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3969 data = new wxPyUserData(userData);
3970 wxPyEndBlockThreads(blocked);
3971 }
3972 return new wxSizerItem(window, proportion, flag, border, data);
3973 }
3974 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3975 wxPyUserData* data = NULL;
3976 if ( userData ) {
3977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3978 data = new wxPyUserData(userData);
3979 wxPyEndBlockThreads(blocked);
3980 }
3981 return new wxSizerItem(width, height, proportion, flag, border, data);
3982 }
3983 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3984 wxPyUserData* data = NULL;
3985 if ( userData ) {
3986 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3987 data = new wxPyUserData(userData);
3988 wxPyEndBlockThreads(blocked);
3989 }
3990 return new wxSizerItem(sizer, proportion, flag, border, data);
3991 }
3992
3993 SWIGINTERNINLINE PyObject *
3994 SWIG_From_float (float value)
3995 {
3996 return SWIG_From_double (value);
3997 }
3998
3999 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4000 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4001 if (data) {
4002 Py_INCREF(data->m_obj);
4003 return data->m_obj;
4004 } else {
4005 Py_INCREF(Py_None);
4006 return Py_None;
4007 }
4008 }
4009 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4010 wxPyUserData* data = NULL;
4011 if ( userData ) {
4012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4013 data = new wxPyUserData(userData);
4014 wxPyEndBlockThreads(blocked);
4015 }
4016 self->SetUserData(data);
4017 }
4018
4019 // Figure out the type of the sizer item
4020
4021 struct wxPySizerItemInfo {
4022 wxPySizerItemInfo()
4023 : window(NULL), sizer(NULL), gotSize(false),
4024 size(wxDefaultSize), gotPos(false), pos(-1)
4025 {}
4026
4027 wxWindow* window;
4028 wxSizer* sizer;
4029 bool gotSize;
4030 wxSize size;
4031 bool gotPos;
4032 int pos;
4033 };
4034
4035 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4036
4037 wxPySizerItemInfo info;
4038 wxSize size;
4039 wxSize* sizePtr = &size;
4040
4041 // Find out what the type of the item is
4042 // try wxWindow
4043 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4044 PyErr_Clear();
4045 info.window = NULL;
4046
4047 // try wxSizer
4048 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4049 PyErr_Clear();
4050 info.sizer = NULL;
4051
4052 // try wxSize or (w,h)
4053 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4054 info.size = *sizePtr;
4055 info.gotSize = true;
4056 }
4057
4058 // or a single int
4059 if (checkIdx && PyInt_Check(item)) {
4060 info.pos = PyInt_AsLong(item);
4061 info.gotPos = true;
4062 }
4063 }
4064 }
4065
4066 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4067 // no expected type, figure out what kind of error message to generate
4068 if ( !checkSize && !checkIdx )
4069 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4070 else if ( checkSize && !checkIdx )
4071 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4072 else if ( !checkSize && checkIdx)
4073 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4074 else
4075 // can this one happen?
4076 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4077 }
4078
4079 return info;
4080 }
4081
4082 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4083 if (!self->GetClientObject())
4084 self->SetClientObject(new wxPyOORClientData(_self));
4085 }
4086 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4087
4088 wxPyUserData* data = NULL;
4089 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4090 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4091 if ( userData && (info.window || info.sizer || info.gotSize) )
4092 data = new wxPyUserData(userData);
4093 if ( info.sizer )
4094 PyObject_SetAttrString(item,"thisown",Py_False);
4095 wxPyEndBlockThreads(blocked);
4096
4097 // Now call the real Add method if a valid item type was found
4098 if ( info.window )
4099 return self->Add(info.window, proportion, flag, border, data);
4100 else if ( info.sizer )
4101 return self->Add(info.sizer, proportion, flag, border, data);
4102 else if (info.gotSize)
4103 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4104 proportion, flag, border, data);
4105 else
4106 return NULL;
4107 }
4108 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4109
4110 wxPyUserData* data = NULL;
4111 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4112 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4113 if ( userData && (info.window || info.sizer || info.gotSize) )
4114 data = new wxPyUserData(userData);
4115 if ( info.sizer )
4116 PyObject_SetAttrString(item,"thisown",Py_False);
4117 wxPyEndBlockThreads(blocked);
4118
4119 // Now call the real Insert method if a valid item type was found
4120 if ( info.window )
4121 return self->Insert(before, info.window, proportion, flag, border, data);
4122 else if ( info.sizer )
4123 return self->Insert(before, info.sizer, proportion, flag, border, data);
4124 else if (info.gotSize)
4125 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4126 proportion, flag, border, data);
4127 else
4128 return NULL;
4129 }
4130 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4131
4132 wxPyUserData* data = NULL;
4133 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4134 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4135 if ( userData && (info.window || info.sizer || info.gotSize) )
4136 data = new wxPyUserData(userData);
4137 if ( info.sizer )
4138 PyObject_SetAttrString(item,"thisown",Py_False);
4139 wxPyEndBlockThreads(blocked);
4140
4141 // Now call the real Prepend method if a valid item type was found
4142 if ( info.window )
4143 return self->Prepend(info.window, proportion, flag, border, data);
4144 else if ( info.sizer )
4145 return self->Prepend(info.sizer, proportion, flag, border, data);
4146 else if (info.gotSize)
4147 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4148 proportion, flag, border, data);
4149 else
4150 return NULL;
4151 }
4152 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4153 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4154 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4155 wxPyEndBlockThreads(blocked);
4156 if ( info.window )
4157 return self->Remove(info.window);
4158 else if ( info.sizer )
4159 return self->Remove(info.sizer);
4160 else if ( info.gotPos )
4161 return self->Remove(info.pos);
4162 else
4163 return false;
4164 }
4165 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4167 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4168 wxPyEndBlockThreads(blocked);
4169 if ( info.window )
4170 return self->Detach(info.window);
4171 else if ( info.sizer )
4172 return self->Detach(info.sizer);
4173 else if ( info.gotPos )
4174 return self->Detach(info.pos);
4175 else
4176 return false;
4177 }
4178 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4180 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4181 wxPyEndBlockThreads(blocked);
4182 if ( info.window )
4183 return self->GetItem(info.window);
4184 else if ( info.sizer )
4185 return self->GetItem(info.sizer);
4186 else if ( info.gotPos )
4187 return self->GetItem(info.pos);
4188 else
4189 return NULL;
4190 }
4191 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4194 wxPyEndBlockThreads(blocked);
4195 if ( info.window )
4196 self->SetItemMinSize(info.window, size);
4197 else if ( info.sizer )
4198 self->SetItemMinSize(info.sizer, size);
4199 else if ( info.gotPos )
4200 self->SetItemMinSize(info.pos, size);
4201 }
4202 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4203 wxSizerItemList& list = self->GetChildren();
4204 return wxPy_ConvertList(&list);
4205 }
4206 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 return self->Show(info.window, show, recursive);
4212 else if ( info.sizer )
4213 return self->Show(info.sizer, show, recursive);
4214 else if ( info.gotPos )
4215 return self->Show(info.pos, show);
4216 else
4217 return false;
4218 }
4219 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4221 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4222 wxPyEndBlockThreads(blocked);
4223 if ( info.window )
4224 return self->IsShown(info.window);
4225 else if ( info.sizer )
4226 return self->IsShown(info.sizer);
4227 else if ( info.gotPos )
4228 return self->IsShown(info.pos);
4229 else
4230 return false;
4231 }
4232
4233 // See pyclasses.h
4234 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4235 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4236 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4237
4238
4239
4240
4241 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4242 {
4243 if (source == Py_None) {
4244 **obj = wxGBPosition(-1,-1);
4245 return true;
4246 }
4247 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4248 }
4249
4250 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4251 {
4252 if (source == Py_None) {
4253 **obj = wxGBSpan(-1,-1);
4254 return true;
4255 }
4256 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4257 }
4258
4259
4260 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4261 wxGBPosition temp, *obj = &temp;
4262 if ( other == Py_None ) return false;
4263 if ( ! wxGBPosition_helper(other, &obj) ) {
4264 PyErr_Clear();
4265 return false;
4266 }
4267 return self->operator==(*obj);
4268 }
4269 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4270 wxGBPosition temp, *obj = &temp;
4271 if ( other == Py_None ) return true;
4272 if ( ! wxGBPosition_helper(other, &obj)) {
4273 PyErr_Clear();
4274 return true;
4275 }
4276 return self->operator!=(*obj);
4277 }
4278 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4279 self->SetRow(row);
4280 self->SetCol(col);
4281 }
4282 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4284 PyObject* tup = PyTuple_New(2);
4285 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4286 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4287 wxPyEndBlockThreads(blocked);
4288 return tup;
4289 }
4290 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4291 wxGBSpan temp, *obj = &temp;
4292 if ( other == Py_None ) return false;
4293 if ( ! wxGBSpan_helper(other, &obj) ) {
4294 PyErr_Clear();
4295 return false;
4296 }
4297 return self->operator==(*obj);
4298 }
4299 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4300 wxGBSpan temp, *obj = &temp;
4301 if ( other == Py_None ) return true;
4302 if ( ! wxGBSpan_helper(other, &obj)) {
4303 PyErr_Clear();
4304 return true;
4305 }
4306 return self->operator!=(*obj);
4307 }
4308 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4309 self->SetRowspan(rowspan);
4310 self->SetColspan(colspan);
4311 }
4312 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4314 PyObject* tup = PyTuple_New(2);
4315 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4316 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4317 wxPyEndBlockThreads(blocked);
4318 return tup;
4319 }
4320 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4321 wxPyUserData* data = NULL;
4322 if ( userData ) {
4323 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4324 data = new wxPyUserData(userData);
4325 wxPyEndBlockThreads(blocked);
4326 }
4327 return new wxGBSizerItem(window, pos, span, flag, border, data);
4328 }
4329 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4330 wxPyUserData* data = NULL;
4331 if ( userData ) {
4332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4333 data = new wxPyUserData(userData);
4334 wxPyEndBlockThreads(blocked);
4335 }
4336 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4337 }
4338 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4339 wxPyUserData* data = NULL;
4340 if ( userData ) {
4341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4342 data = new wxPyUserData(userData);
4343 wxPyEndBlockThreads(blocked);
4344 }
4345 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4346 }
4347 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4348 int row, col;
4349 self->GetEndPos(row, col);
4350 return wxGBPosition(row, col);
4351 }
4352 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4353
4354 wxPyUserData* data = NULL;
4355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4356 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4357 if ( userData && (info.window || info.sizer || info.gotSize) )
4358 data = new wxPyUserData(userData);
4359 if ( info.sizer )
4360 PyObject_SetAttrString(item,"thisown",Py_False);
4361 wxPyEndBlockThreads(blocked);
4362
4363 // Now call the real Add method if a valid item type was found
4364 if ( info.window )
4365 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4366 else if ( info.sizer )
4367 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4368 else if (info.gotSize)
4369 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4370 pos, span, flag, border, data);
4371 return NULL;
4372 }
4373
4374
4375 #ifdef __cplusplus
4376 extern "C" {
4377 #endif
4378 SWIGINTERN int EmptyString_set(PyObject *) {
4379 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4380 return 1;
4381 }
4382
4383
4384 SWIGINTERN PyObject *EmptyString_get(void) {
4385 PyObject *pyobj = 0;
4386
4387 {
4388 #if wxUSE_UNICODE
4389 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4390 #else
4391 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4392 #endif
4393 }
4394 return pyobj;
4395 }
4396
4397
4398 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4399 PyObject *resultobj = 0;
4400 wxObject *arg1 = (wxObject *) 0 ;
4401 wxString result;
4402 void *argp1 = 0 ;
4403 int res1 = 0 ;
4404 PyObject *swig_obj[1] ;
4405
4406 if (!args) SWIG_fail;
4407 swig_obj[0] = args;
4408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4409 if (!SWIG_IsOK(res1)) {
4410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4411 }
4412 arg1 = reinterpret_cast< wxObject * >(argp1);
4413 {
4414 PyThreadState* __tstate = wxPyBeginAllowThreads();
4415 result = wxObject_GetClassName(arg1);
4416 wxPyEndAllowThreads(__tstate);
4417 if (PyErr_Occurred()) SWIG_fail;
4418 }
4419 {
4420 #if wxUSE_UNICODE
4421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4422 #else
4423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4424 #endif
4425 }
4426 return resultobj;
4427 fail:
4428 return NULL;
4429 }
4430
4431
4432 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4433 PyObject *resultobj = 0;
4434 wxObject *arg1 = (wxObject *) 0 ;
4435 void *argp1 = 0 ;
4436 int res1 = 0 ;
4437 PyObject *swig_obj[1] ;
4438
4439 if (!args) SWIG_fail;
4440 swig_obj[0] = args;
4441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4442 if (!SWIG_IsOK(res1)) {
4443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4444 }
4445 arg1 = reinterpret_cast< wxObject * >(argp1);
4446 {
4447 PyThreadState* __tstate = wxPyBeginAllowThreads();
4448 wxObject_Destroy(arg1);
4449 wxPyEndAllowThreads(__tstate);
4450 if (PyErr_Occurred()) SWIG_fail;
4451 }
4452 resultobj = SWIG_Py_Void();
4453 return resultobj;
4454 fail:
4455 return NULL;
4456 }
4457
4458
4459 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4460 PyObject *obj;
4461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4462 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4463 return SWIG_Py_Void();
4464 }
4465
4466 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4467 PyObject *resultobj = 0;
4468 wxSize *arg1 = (wxSize *) 0 ;
4469 int arg2 ;
4470 void *argp1 = 0 ;
4471 int res1 = 0 ;
4472 int val2 ;
4473 int ecode2 = 0 ;
4474 PyObject *swig_obj[2] ;
4475
4476 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4478 if (!SWIG_IsOK(res1)) {
4479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4480 }
4481 arg1 = reinterpret_cast< wxSize * >(argp1);
4482 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4483 if (!SWIG_IsOK(ecode2)) {
4484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4485 }
4486 arg2 = static_cast< int >(val2);
4487 if (arg1) (arg1)->x = arg2;
4488
4489 resultobj = SWIG_Py_Void();
4490 return resultobj;
4491 fail:
4492 return NULL;
4493 }
4494
4495
4496 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4497 PyObject *resultobj = 0;
4498 wxSize *arg1 = (wxSize *) 0 ;
4499 int result;
4500 void *argp1 = 0 ;
4501 int res1 = 0 ;
4502 PyObject *swig_obj[1] ;
4503
4504 if (!args) SWIG_fail;
4505 swig_obj[0] = args;
4506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4507 if (!SWIG_IsOK(res1)) {
4508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4509 }
4510 arg1 = reinterpret_cast< wxSize * >(argp1);
4511 result = (int) ((arg1)->x);
4512 resultobj = SWIG_From_int(static_cast< int >(result));
4513 return resultobj;
4514 fail:
4515 return NULL;
4516 }
4517
4518
4519 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4520 PyObject *resultobj = 0;
4521 wxSize *arg1 = (wxSize *) 0 ;
4522 int arg2 ;
4523 void *argp1 = 0 ;
4524 int res1 = 0 ;
4525 int val2 ;
4526 int ecode2 = 0 ;
4527 PyObject *swig_obj[2] ;
4528
4529 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4531 if (!SWIG_IsOK(res1)) {
4532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4533 }
4534 arg1 = reinterpret_cast< wxSize * >(argp1);
4535 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4536 if (!SWIG_IsOK(ecode2)) {
4537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4538 }
4539 arg2 = static_cast< int >(val2);
4540 if (arg1) (arg1)->y = arg2;
4541
4542 resultobj = SWIG_Py_Void();
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4550 PyObject *resultobj = 0;
4551 wxSize *arg1 = (wxSize *) 0 ;
4552 int result;
4553 void *argp1 = 0 ;
4554 int res1 = 0 ;
4555 PyObject *swig_obj[1] ;
4556
4557 if (!args) SWIG_fail;
4558 swig_obj[0] = args;
4559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4560 if (!SWIG_IsOK(res1)) {
4561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4562 }
4563 arg1 = reinterpret_cast< wxSize * >(argp1);
4564 result = (int) ((arg1)->y);
4565 resultobj = SWIG_From_int(static_cast< int >(result));
4566 return resultobj;
4567 fail:
4568 return NULL;
4569 }
4570
4571
4572 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4573 PyObject *resultobj = 0;
4574 int arg1 = (int) 0 ;
4575 int arg2 = (int) 0 ;
4576 wxSize *result = 0 ;
4577 int val1 ;
4578 int ecode1 = 0 ;
4579 int val2 ;
4580 int ecode2 = 0 ;
4581 PyObject * obj0 = 0 ;
4582 PyObject * obj1 = 0 ;
4583 char * kwnames[] = {
4584 (char *) "w",(char *) "h", NULL
4585 };
4586
4587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4588 if (obj0) {
4589 ecode1 = SWIG_AsVal_int(obj0, &val1);
4590 if (!SWIG_IsOK(ecode1)) {
4591 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4592 }
4593 arg1 = static_cast< int >(val1);
4594 }
4595 if (obj1) {
4596 ecode2 = SWIG_AsVal_int(obj1, &val2);
4597 if (!SWIG_IsOK(ecode2)) {
4598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4599 }
4600 arg2 = static_cast< int >(val2);
4601 }
4602 {
4603 PyThreadState* __tstate = wxPyBeginAllowThreads();
4604 result = (wxSize *)new wxSize(arg1,arg2);
4605 wxPyEndAllowThreads(__tstate);
4606 if (PyErr_Occurred()) SWIG_fail;
4607 }
4608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4616 PyObject *resultobj = 0;
4617 wxSize *arg1 = (wxSize *) 0 ;
4618 void *argp1 = 0 ;
4619 int res1 = 0 ;
4620 PyObject *swig_obj[1] ;
4621
4622 if (!args) SWIG_fail;
4623 swig_obj[0] = args;
4624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4625 if (!SWIG_IsOK(res1)) {
4626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4627 }
4628 arg1 = reinterpret_cast< wxSize * >(argp1);
4629 {
4630 PyThreadState* __tstate = wxPyBeginAllowThreads();
4631 delete arg1;
4632
4633 wxPyEndAllowThreads(__tstate);
4634 if (PyErr_Occurred()) SWIG_fail;
4635 }
4636 resultobj = SWIG_Py_Void();
4637 return resultobj;
4638 fail:
4639 return NULL;
4640 }
4641
4642
4643 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4644 PyObject *resultobj = 0;
4645 wxSize *arg1 = (wxSize *) 0 ;
4646 PyObject *arg2 = (PyObject *) 0 ;
4647 bool result;
4648 void *argp1 = 0 ;
4649 int res1 = 0 ;
4650 PyObject * obj0 = 0 ;
4651 PyObject * obj1 = 0 ;
4652 char * kwnames[] = {
4653 (char *) "self",(char *) "other", NULL
4654 };
4655
4656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4658 if (!SWIG_IsOK(res1)) {
4659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4660 }
4661 arg1 = reinterpret_cast< wxSize * >(argp1);
4662 arg2 = obj1;
4663 {
4664 result = (bool)wxSize___eq__(arg1,arg2);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 {
4668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4669 }
4670 return resultobj;
4671 fail:
4672 return NULL;
4673 }
4674
4675
4676 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4677 PyObject *resultobj = 0;
4678 wxSize *arg1 = (wxSize *) 0 ;
4679 PyObject *arg2 = (PyObject *) 0 ;
4680 bool result;
4681 void *argp1 = 0 ;
4682 int res1 = 0 ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 char * kwnames[] = {
4686 (char *) "self",(char *) "other", NULL
4687 };
4688
4689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4691 if (!SWIG_IsOK(res1)) {
4692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4693 }
4694 arg1 = reinterpret_cast< wxSize * >(argp1);
4695 arg2 = obj1;
4696 {
4697 result = (bool)wxSize___ne__(arg1,arg2);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 {
4701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4702 }
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj = 0;
4711 wxSize *arg1 = (wxSize *) 0 ;
4712 wxSize *arg2 = 0 ;
4713 wxSize result;
4714 void *argp1 = 0 ;
4715 int res1 = 0 ;
4716 wxSize temp2 ;
4717 PyObject * obj0 = 0 ;
4718 PyObject * obj1 = 0 ;
4719 char * kwnames[] = {
4720 (char *) "self",(char *) "sz", NULL
4721 };
4722
4723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4725 if (!SWIG_IsOK(res1)) {
4726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4727 }
4728 arg1 = reinterpret_cast< wxSize * >(argp1);
4729 {
4730 arg2 = &temp2;
4731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4732 }
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 result = (arg1)->operator +((wxSize const &)*arg2);
4736 wxPyEndAllowThreads(__tstate);
4737 if (PyErr_Occurred()) SWIG_fail;
4738 }
4739 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4740 return resultobj;
4741 fail:
4742 return NULL;
4743 }
4744
4745
4746 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4747 PyObject *resultobj = 0;
4748 wxSize *arg1 = (wxSize *) 0 ;
4749 wxSize *arg2 = 0 ;
4750 wxSize result;
4751 void *argp1 = 0 ;
4752 int res1 = 0 ;
4753 wxSize temp2 ;
4754 PyObject * obj0 = 0 ;
4755 PyObject * obj1 = 0 ;
4756 char * kwnames[] = {
4757 (char *) "self",(char *) "sz", NULL
4758 };
4759
4760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4762 if (!SWIG_IsOK(res1)) {
4763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4764 }
4765 arg1 = reinterpret_cast< wxSize * >(argp1);
4766 {
4767 arg2 = &temp2;
4768 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 result = (arg1)->operator -((wxSize const &)*arg2);
4773 wxPyEndAllowThreads(__tstate);
4774 if (PyErr_Occurred()) SWIG_fail;
4775 }
4776 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4777 return resultobj;
4778 fail:
4779 return NULL;
4780 }
4781
4782
4783 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4784 PyObject *resultobj = 0;
4785 wxSize *arg1 = (wxSize *) 0 ;
4786 wxSize *arg2 = 0 ;
4787 void *argp1 = 0 ;
4788 int res1 = 0 ;
4789 wxSize temp2 ;
4790 PyObject * obj0 = 0 ;
4791 PyObject * obj1 = 0 ;
4792 char * kwnames[] = {
4793 (char *) "self",(char *) "sz", NULL
4794 };
4795
4796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4798 if (!SWIG_IsOK(res1)) {
4799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4800 }
4801 arg1 = reinterpret_cast< wxSize * >(argp1);
4802 {
4803 arg2 = &temp2;
4804 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4805 }
4806 {
4807 PyThreadState* __tstate = wxPyBeginAllowThreads();
4808 (arg1)->IncTo((wxSize const &)*arg2);
4809 wxPyEndAllowThreads(__tstate);
4810 if (PyErr_Occurred()) SWIG_fail;
4811 }
4812 resultobj = SWIG_Py_Void();
4813 return resultobj;
4814 fail:
4815 return NULL;
4816 }
4817
4818
4819 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4820 PyObject *resultobj = 0;
4821 wxSize *arg1 = (wxSize *) 0 ;
4822 wxSize *arg2 = 0 ;
4823 void *argp1 = 0 ;
4824 int res1 = 0 ;
4825 wxSize temp2 ;
4826 PyObject * obj0 = 0 ;
4827 PyObject * obj1 = 0 ;
4828 char * kwnames[] = {
4829 (char *) "self",(char *) "sz", NULL
4830 };
4831
4832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4834 if (!SWIG_IsOK(res1)) {
4835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4836 }
4837 arg1 = reinterpret_cast< wxSize * >(argp1);
4838 {
4839 arg2 = &temp2;
4840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4841 }
4842 {
4843 PyThreadState* __tstate = wxPyBeginAllowThreads();
4844 (arg1)->DecTo((wxSize const &)*arg2);
4845 wxPyEndAllowThreads(__tstate);
4846 if (PyErr_Occurred()) SWIG_fail;
4847 }
4848 resultobj = SWIG_Py_Void();
4849 return resultobj;
4850 fail:
4851 return NULL;
4852 }
4853
4854
4855 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4856 PyObject *resultobj = 0;
4857 wxSize *arg1 = (wxSize *) 0 ;
4858 float arg2 ;
4859 float arg3 ;
4860 void *argp1 = 0 ;
4861 int res1 = 0 ;
4862 float val2 ;
4863 int ecode2 = 0 ;
4864 float val3 ;
4865 int ecode3 = 0 ;
4866 PyObject * obj0 = 0 ;
4867 PyObject * obj1 = 0 ;
4868 PyObject * obj2 = 0 ;
4869 char * kwnames[] = {
4870 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4871 };
4872
4873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4875 if (!SWIG_IsOK(res1)) {
4876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4877 }
4878 arg1 = reinterpret_cast< wxSize * >(argp1);
4879 ecode2 = SWIG_AsVal_float(obj1, &val2);
4880 if (!SWIG_IsOK(ecode2)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4882 }
4883 arg2 = static_cast< float >(val2);
4884 ecode3 = SWIG_AsVal_float(obj2, &val3);
4885 if (!SWIG_IsOK(ecode3)) {
4886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4887 }
4888 arg3 = static_cast< float >(val3);
4889 {
4890 PyThreadState* __tstate = wxPyBeginAllowThreads();
4891 (arg1)->Scale(arg2,arg3);
4892 wxPyEndAllowThreads(__tstate);
4893 if (PyErr_Occurred()) SWIG_fail;
4894 }
4895 resultobj = SWIG_Py_Void();
4896 return resultobj;
4897 fail:
4898 return NULL;
4899 }
4900
4901
4902 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4903 PyObject *resultobj = 0;
4904 wxSize *arg1 = (wxSize *) 0 ;
4905 int arg2 ;
4906 int arg3 ;
4907 void *argp1 = 0 ;
4908 int res1 = 0 ;
4909 int val2 ;
4910 int ecode2 = 0 ;
4911 int val3 ;
4912 int ecode3 = 0 ;
4913 PyObject * obj0 = 0 ;
4914 PyObject * obj1 = 0 ;
4915 PyObject * obj2 = 0 ;
4916 char * kwnames[] = {
4917 (char *) "self",(char *) "w",(char *) "h", NULL
4918 };
4919
4920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4922 if (!SWIG_IsOK(res1)) {
4923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4924 }
4925 arg1 = reinterpret_cast< wxSize * >(argp1);
4926 ecode2 = SWIG_AsVal_int(obj1, &val2);
4927 if (!SWIG_IsOK(ecode2)) {
4928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4929 }
4930 arg2 = static_cast< int >(val2);
4931 ecode3 = SWIG_AsVal_int(obj2, &val3);
4932 if (!SWIG_IsOK(ecode3)) {
4933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4934 }
4935 arg3 = static_cast< int >(val3);
4936 {
4937 PyThreadState* __tstate = wxPyBeginAllowThreads();
4938 (arg1)->Set(arg2,arg3);
4939 wxPyEndAllowThreads(__tstate);
4940 if (PyErr_Occurred()) SWIG_fail;
4941 }
4942 resultobj = SWIG_Py_Void();
4943 return resultobj;
4944 fail:
4945 return NULL;
4946 }
4947
4948
4949 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4950 PyObject *resultobj = 0;
4951 wxSize *arg1 = (wxSize *) 0 ;
4952 int arg2 ;
4953 void *argp1 = 0 ;
4954 int res1 = 0 ;
4955 int val2 ;
4956 int ecode2 = 0 ;
4957 PyObject * obj0 = 0 ;
4958 PyObject * obj1 = 0 ;
4959 char * kwnames[] = {
4960 (char *) "self",(char *) "w", NULL
4961 };
4962
4963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4965 if (!SWIG_IsOK(res1)) {
4966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4967 }
4968 arg1 = reinterpret_cast< wxSize * >(argp1);
4969 ecode2 = SWIG_AsVal_int(obj1, &val2);
4970 if (!SWIG_IsOK(ecode2)) {
4971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4972 }
4973 arg2 = static_cast< int >(val2);
4974 {
4975 PyThreadState* __tstate = wxPyBeginAllowThreads();
4976 (arg1)->SetWidth(arg2);
4977 wxPyEndAllowThreads(__tstate);
4978 if (PyErr_Occurred()) SWIG_fail;
4979 }
4980 resultobj = SWIG_Py_Void();
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj = 0;
4989 wxSize *arg1 = (wxSize *) 0 ;
4990 int arg2 ;
4991 void *argp1 = 0 ;
4992 int res1 = 0 ;
4993 int val2 ;
4994 int ecode2 = 0 ;
4995 PyObject * obj0 = 0 ;
4996 PyObject * obj1 = 0 ;
4997 char * kwnames[] = {
4998 (char *) "self",(char *) "h", NULL
4999 };
5000
5001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5003 if (!SWIG_IsOK(res1)) {
5004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5005 }
5006 arg1 = reinterpret_cast< wxSize * >(argp1);
5007 ecode2 = SWIG_AsVal_int(obj1, &val2);
5008 if (!SWIG_IsOK(ecode2)) {
5009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5010 }
5011 arg2 = static_cast< int >(val2);
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 (arg1)->SetHeight(arg2);
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 resultobj = SWIG_Py_Void();
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026 PyObject *resultobj = 0;
5027 wxSize *arg1 = (wxSize *) 0 ;
5028 int result;
5029 void *argp1 = 0 ;
5030 int res1 = 0 ;
5031 PyObject *swig_obj[1] ;
5032
5033 if (!args) SWIG_fail;
5034 swig_obj[0] = args;
5035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5036 if (!SWIG_IsOK(res1)) {
5037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5038 }
5039 arg1 = reinterpret_cast< wxSize * >(argp1);
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (int)((wxSize const *)arg1)->GetWidth();
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 resultobj = SWIG_From_int(static_cast< int >(result));
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5054 PyObject *resultobj = 0;
5055 wxSize *arg1 = (wxSize *) 0 ;
5056 int result;
5057 void *argp1 = 0 ;
5058 int res1 = 0 ;
5059 PyObject *swig_obj[1] ;
5060
5061 if (!args) SWIG_fail;
5062 swig_obj[0] = args;
5063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5064 if (!SWIG_IsOK(res1)) {
5065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5066 }
5067 arg1 = reinterpret_cast< wxSize * >(argp1);
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = (int)((wxSize const *)arg1)->GetHeight();
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_From_int(static_cast< int >(result));
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5082 PyObject *resultobj = 0;
5083 wxSize *arg1 = (wxSize *) 0 ;
5084 bool result;
5085 void *argp1 = 0 ;
5086 int res1 = 0 ;
5087 PyObject *swig_obj[1] ;
5088
5089 if (!args) SWIG_fail;
5090 swig_obj[0] = args;
5091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5094 }
5095 arg1 = reinterpret_cast< wxSize * >(argp1);
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 {
5103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5104 }
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj = 0;
5113 wxSize *arg1 = (wxSize *) 0 ;
5114 wxSize *arg2 = 0 ;
5115 void *argp1 = 0 ;
5116 int res1 = 0 ;
5117 wxSize temp2 ;
5118 PyObject * obj0 = 0 ;
5119 PyObject * obj1 = 0 ;
5120 char * kwnames[] = {
5121 (char *) "self",(char *) "size", NULL
5122 };
5123
5124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5126 if (!SWIG_IsOK(res1)) {
5127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5128 }
5129 arg1 = reinterpret_cast< wxSize * >(argp1);
5130 {
5131 arg2 = &temp2;
5132 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5133 }
5134 {
5135 PyThreadState* __tstate = wxPyBeginAllowThreads();
5136 (arg1)->SetDefaults((wxSize const &)*arg2);
5137 wxPyEndAllowThreads(__tstate);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 resultobj = SWIG_Py_Void();
5141 return resultobj;
5142 fail:
5143 return NULL;
5144 }
5145
5146
5147 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5148 PyObject *resultobj = 0;
5149 wxSize *arg1 = (wxSize *) 0 ;
5150 PyObject *result = 0 ;
5151 void *argp1 = 0 ;
5152 int res1 = 0 ;
5153 PyObject *swig_obj[1] ;
5154
5155 if (!args) SWIG_fail;
5156 swig_obj[0] = args;
5157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5158 if (!SWIG_IsOK(res1)) {
5159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5160 }
5161 arg1 = reinterpret_cast< wxSize * >(argp1);
5162 {
5163 PyThreadState* __tstate = wxPyBeginAllowThreads();
5164 result = (PyObject *)wxSize_Get(arg1);
5165 wxPyEndAllowThreads(__tstate);
5166 if (PyErr_Occurred()) SWIG_fail;
5167 }
5168 resultobj = result;
5169 return resultobj;
5170 fail:
5171 return NULL;
5172 }
5173
5174
5175 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5176 PyObject *obj;
5177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5178 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5179 return SWIG_Py_Void();
5180 }
5181
5182 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 return SWIG_Python_InitShadowInstance(args);
5184 }
5185
5186 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5187 PyObject *resultobj = 0;
5188 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5189 double arg2 ;
5190 void *argp1 = 0 ;
5191 int res1 = 0 ;
5192 double val2 ;
5193 int ecode2 = 0 ;
5194 PyObject *swig_obj[2] ;
5195
5196 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5198 if (!SWIG_IsOK(res1)) {
5199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5200 }
5201 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5202 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5203 if (!SWIG_IsOK(ecode2)) {
5204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5205 }
5206 arg2 = static_cast< double >(val2);
5207 if (arg1) (arg1)->x = arg2;
5208
5209 resultobj = SWIG_Py_Void();
5210 return resultobj;
5211 fail:
5212 return NULL;
5213 }
5214
5215
5216 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5217 PyObject *resultobj = 0;
5218 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5219 double result;
5220 void *argp1 = 0 ;
5221 int res1 = 0 ;
5222 PyObject *swig_obj[1] ;
5223
5224 if (!args) SWIG_fail;
5225 swig_obj[0] = args;
5226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5227 if (!SWIG_IsOK(res1)) {
5228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5229 }
5230 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5231 result = (double) ((arg1)->x);
5232 resultobj = SWIG_From_double(static_cast< double >(result));
5233 return resultobj;
5234 fail:
5235 return NULL;
5236 }
5237
5238
5239 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5240 PyObject *resultobj = 0;
5241 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5242 double arg2 ;
5243 void *argp1 = 0 ;
5244 int res1 = 0 ;
5245 double val2 ;
5246 int ecode2 = 0 ;
5247 PyObject *swig_obj[2] ;
5248
5249 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5251 if (!SWIG_IsOK(res1)) {
5252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5253 }
5254 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5255 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5256 if (!SWIG_IsOK(ecode2)) {
5257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5258 }
5259 arg2 = static_cast< double >(val2);
5260 if (arg1) (arg1)->y = arg2;
5261
5262 resultobj = SWIG_Py_Void();
5263 return resultobj;
5264 fail:
5265 return NULL;
5266 }
5267
5268
5269 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5270 PyObject *resultobj = 0;
5271 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5272 double result;
5273 void *argp1 = 0 ;
5274 int res1 = 0 ;
5275 PyObject *swig_obj[1] ;
5276
5277 if (!args) SWIG_fail;
5278 swig_obj[0] = args;
5279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5280 if (!SWIG_IsOK(res1)) {
5281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5282 }
5283 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5284 result = (double) ((arg1)->y);
5285 resultobj = SWIG_From_double(static_cast< double >(result));
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj = 0;
5294 double arg1 = (double) 0.0 ;
5295 double arg2 = (double) 0.0 ;
5296 wxRealPoint *result = 0 ;
5297 double val1 ;
5298 int ecode1 = 0 ;
5299 double val2 ;
5300 int ecode2 = 0 ;
5301 PyObject * obj0 = 0 ;
5302 PyObject * obj1 = 0 ;
5303 char * kwnames[] = {
5304 (char *) "x",(char *) "y", NULL
5305 };
5306
5307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5308 if (obj0) {
5309 ecode1 = SWIG_AsVal_double(obj0, &val1);
5310 if (!SWIG_IsOK(ecode1)) {
5311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5312 }
5313 arg1 = static_cast< double >(val1);
5314 }
5315 if (obj1) {
5316 ecode2 = SWIG_AsVal_double(obj1, &val2);
5317 if (!SWIG_IsOK(ecode2)) {
5318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5319 }
5320 arg2 = static_cast< double >(val2);
5321 }
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5336 PyObject *resultobj = 0;
5337 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 PyObject *swig_obj[1] ;
5341
5342 if (!args) SWIG_fail;
5343 swig_obj[0] = args;
5344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5345 if (!SWIG_IsOK(res1)) {
5346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5347 }
5348 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 delete arg1;
5352
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 resultobj = SWIG_Py_Void();
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5364 PyObject *resultobj = 0;
5365 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5366 PyObject *arg2 = (PyObject *) 0 ;
5367 bool result;
5368 void *argp1 = 0 ;
5369 int res1 = 0 ;
5370 PyObject * obj0 = 0 ;
5371 PyObject * obj1 = 0 ;
5372 char * kwnames[] = {
5373 (char *) "self",(char *) "other", NULL
5374 };
5375
5376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5378 if (!SWIG_IsOK(res1)) {
5379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5380 }
5381 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5382 arg2 = obj1;
5383 {
5384 result = (bool)wxRealPoint___eq__(arg1,arg2);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 {
5388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5389 }
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5397 PyObject *resultobj = 0;
5398 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5399 PyObject *arg2 = (PyObject *) 0 ;
5400 bool result;
5401 void *argp1 = 0 ;
5402 int res1 = 0 ;
5403 PyObject * obj0 = 0 ;
5404 PyObject * obj1 = 0 ;
5405 char * kwnames[] = {
5406 (char *) "self",(char *) "other", NULL
5407 };
5408
5409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5411 if (!SWIG_IsOK(res1)) {
5412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5413 }
5414 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5415 arg2 = obj1;
5416 {
5417 result = (bool)wxRealPoint___ne__(arg1,arg2);
5418 if (PyErr_Occurred()) SWIG_fail;
5419 }
5420 {
5421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5422 }
5423 return resultobj;
5424 fail:
5425 return NULL;
5426 }
5427
5428
5429 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5430 PyObject *resultobj = 0;
5431 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5432 wxRealPoint *arg2 = 0 ;
5433 wxRealPoint result;
5434 void *argp1 = 0 ;
5435 int res1 = 0 ;
5436 wxRealPoint temp2 ;
5437 PyObject * obj0 = 0 ;
5438 PyObject * obj1 = 0 ;
5439 char * kwnames[] = {
5440 (char *) "self",(char *) "pt", NULL
5441 };
5442
5443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5445 if (!SWIG_IsOK(res1)) {
5446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5447 }
5448 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5449 {
5450 arg2 = &temp2;
5451 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5452 }
5453 {
5454 PyThreadState* __tstate = wxPyBeginAllowThreads();
5455 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5460 return resultobj;
5461 fail:
5462 return NULL;
5463 }
5464
5465
5466 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5467 PyObject *resultobj = 0;
5468 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5469 wxRealPoint *arg2 = 0 ;
5470 wxRealPoint result;
5471 void *argp1 = 0 ;
5472 int res1 = 0 ;
5473 wxRealPoint temp2 ;
5474 PyObject * obj0 = 0 ;
5475 PyObject * obj1 = 0 ;
5476 char * kwnames[] = {
5477 (char *) "self",(char *) "pt", NULL
5478 };
5479
5480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5482 if (!SWIG_IsOK(res1)) {
5483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5484 }
5485 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5486 {
5487 arg2 = &temp2;
5488 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5489 }
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5493 wxPyEndAllowThreads(__tstate);
5494 if (PyErr_Occurred()) SWIG_fail;
5495 }
5496 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5497 return resultobj;
5498 fail:
5499 return NULL;
5500 }
5501
5502
5503 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5504 PyObject *resultobj = 0;
5505 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5506 double arg2 ;
5507 double arg3 ;
5508 void *argp1 = 0 ;
5509 int res1 = 0 ;
5510 double val2 ;
5511 int ecode2 = 0 ;
5512 double val3 ;
5513 int ecode3 = 0 ;
5514 PyObject * obj0 = 0 ;
5515 PyObject * obj1 = 0 ;
5516 PyObject * obj2 = 0 ;
5517 char * kwnames[] = {
5518 (char *) "self",(char *) "x",(char *) "y", NULL
5519 };
5520
5521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5523 if (!SWIG_IsOK(res1)) {
5524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5525 }
5526 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5527 ecode2 = SWIG_AsVal_double(obj1, &val2);
5528 if (!SWIG_IsOK(ecode2)) {
5529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5530 }
5531 arg2 = static_cast< double >(val2);
5532 ecode3 = SWIG_AsVal_double(obj2, &val3);
5533 if (!SWIG_IsOK(ecode3)) {
5534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5535 }
5536 arg3 = static_cast< double >(val3);
5537 {
5538 PyThreadState* __tstate = wxPyBeginAllowThreads();
5539 wxRealPoint_Set(arg1,arg2,arg3);
5540 wxPyEndAllowThreads(__tstate);
5541 if (PyErr_Occurred()) SWIG_fail;
5542 }
5543 resultobj = SWIG_Py_Void();
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5551 PyObject *resultobj = 0;
5552 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5553 PyObject *result = 0 ;
5554 void *argp1 = 0 ;
5555 int res1 = 0 ;
5556 PyObject *swig_obj[1] ;
5557
5558 if (!args) SWIG_fail;
5559 swig_obj[0] = args;
5560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5561 if (!SWIG_IsOK(res1)) {
5562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5563 }
5564 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5565 {
5566 PyThreadState* __tstate = wxPyBeginAllowThreads();
5567 result = (PyObject *)wxRealPoint_Get(arg1);
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 resultobj = result;
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5579 PyObject *obj;
5580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5581 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5582 return SWIG_Py_Void();
5583 }
5584
5585 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586 return SWIG_Python_InitShadowInstance(args);
5587 }
5588
5589 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5590 PyObject *resultobj = 0;
5591 wxPoint *arg1 = (wxPoint *) 0 ;
5592 int arg2 ;
5593 void *argp1 = 0 ;
5594 int res1 = 0 ;
5595 int val2 ;
5596 int ecode2 = 0 ;
5597 PyObject *swig_obj[2] ;
5598
5599 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5601 if (!SWIG_IsOK(res1)) {
5602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5603 }
5604 arg1 = reinterpret_cast< wxPoint * >(argp1);
5605 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5606 if (!SWIG_IsOK(ecode2)) {
5607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5608 }
5609 arg2 = static_cast< int >(val2);
5610 if (arg1) (arg1)->x = arg2;
5611
5612 resultobj = SWIG_Py_Void();
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5620 PyObject *resultobj = 0;
5621 wxPoint *arg1 = (wxPoint *) 0 ;
5622 int result;
5623 void *argp1 = 0 ;
5624 int res1 = 0 ;
5625 PyObject *swig_obj[1] ;
5626
5627 if (!args) SWIG_fail;
5628 swig_obj[0] = args;
5629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5630 if (!SWIG_IsOK(res1)) {
5631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5632 }
5633 arg1 = reinterpret_cast< wxPoint * >(argp1);
5634 result = (int) ((arg1)->x);
5635 resultobj = SWIG_From_int(static_cast< int >(result));
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5643 PyObject *resultobj = 0;
5644 wxPoint *arg1 = (wxPoint *) 0 ;
5645 int arg2 ;
5646 void *argp1 = 0 ;
5647 int res1 = 0 ;
5648 int val2 ;
5649 int ecode2 = 0 ;
5650 PyObject *swig_obj[2] ;
5651
5652 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5654 if (!SWIG_IsOK(res1)) {
5655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5656 }
5657 arg1 = reinterpret_cast< wxPoint * >(argp1);
5658 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5659 if (!SWIG_IsOK(ecode2)) {
5660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5661 }
5662 arg2 = static_cast< int >(val2);
5663 if (arg1) (arg1)->y = arg2;
5664
5665 resultobj = SWIG_Py_Void();
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5673 PyObject *resultobj = 0;
5674 wxPoint *arg1 = (wxPoint *) 0 ;
5675 int result;
5676 void *argp1 = 0 ;
5677 int res1 = 0 ;
5678 PyObject *swig_obj[1] ;
5679
5680 if (!args) SWIG_fail;
5681 swig_obj[0] = args;
5682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5683 if (!SWIG_IsOK(res1)) {
5684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5685 }
5686 arg1 = reinterpret_cast< wxPoint * >(argp1);
5687 result = (int) ((arg1)->y);
5688 resultobj = SWIG_From_int(static_cast< int >(result));
5689 return resultobj;
5690 fail:
5691 return NULL;
5692 }
5693
5694
5695 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5696 PyObject *resultobj = 0;
5697 int arg1 = (int) 0 ;
5698 int arg2 = (int) 0 ;
5699 wxPoint *result = 0 ;
5700 int val1 ;
5701 int ecode1 = 0 ;
5702 int val2 ;
5703 int ecode2 = 0 ;
5704 PyObject * obj0 = 0 ;
5705 PyObject * obj1 = 0 ;
5706 char * kwnames[] = {
5707 (char *) "x",(char *) "y", NULL
5708 };
5709
5710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5711 if (obj0) {
5712 ecode1 = SWIG_AsVal_int(obj0, &val1);
5713 if (!SWIG_IsOK(ecode1)) {
5714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5715 }
5716 arg1 = static_cast< int >(val1);
5717 }
5718 if (obj1) {
5719 ecode2 = SWIG_AsVal_int(obj1, &val2);
5720 if (!SWIG_IsOK(ecode2)) {
5721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5722 }
5723 arg2 = static_cast< int >(val2);
5724 }
5725 {
5726 PyThreadState* __tstate = wxPyBeginAllowThreads();
5727 result = (wxPoint *)new wxPoint(arg1,arg2);
5728 wxPyEndAllowThreads(__tstate);
5729 if (PyErr_Occurred()) SWIG_fail;
5730 }
5731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5732 return resultobj;
5733 fail:
5734 return NULL;
5735 }
5736
5737
5738 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5739 PyObject *resultobj = 0;
5740 wxPoint *arg1 = (wxPoint *) 0 ;
5741 void *argp1 = 0 ;
5742 int res1 = 0 ;
5743 PyObject *swig_obj[1] ;
5744
5745 if (!args) SWIG_fail;
5746 swig_obj[0] = args;
5747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5748 if (!SWIG_IsOK(res1)) {
5749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5750 }
5751 arg1 = reinterpret_cast< wxPoint * >(argp1);
5752 {
5753 PyThreadState* __tstate = wxPyBeginAllowThreads();
5754 delete arg1;
5755
5756 wxPyEndAllowThreads(__tstate);
5757 if (PyErr_Occurred()) SWIG_fail;
5758 }
5759 resultobj = SWIG_Py_Void();
5760 return resultobj;
5761 fail:
5762 return NULL;
5763 }
5764
5765
5766 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5767 PyObject *resultobj = 0;
5768 wxPoint *arg1 = (wxPoint *) 0 ;
5769 PyObject *arg2 = (PyObject *) 0 ;
5770 bool result;
5771 void *argp1 = 0 ;
5772 int res1 = 0 ;
5773 PyObject * obj0 = 0 ;
5774 PyObject * obj1 = 0 ;
5775 char * kwnames[] = {
5776 (char *) "self",(char *) "other", NULL
5777 };
5778
5779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5781 if (!SWIG_IsOK(res1)) {
5782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5783 }
5784 arg1 = reinterpret_cast< wxPoint * >(argp1);
5785 arg2 = obj1;
5786 {
5787 result = (bool)wxPoint___eq__(arg1,arg2);
5788 if (PyErr_Occurred()) SWIG_fail;
5789 }
5790 {
5791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5792 }
5793 return resultobj;
5794 fail:
5795 return NULL;
5796 }
5797
5798
5799 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5800 PyObject *resultobj = 0;
5801 wxPoint *arg1 = (wxPoint *) 0 ;
5802 PyObject *arg2 = (PyObject *) 0 ;
5803 bool result;
5804 void *argp1 = 0 ;
5805 int res1 = 0 ;
5806 PyObject * obj0 = 0 ;
5807 PyObject * obj1 = 0 ;
5808 char * kwnames[] = {
5809 (char *) "self",(char *) "other", NULL
5810 };
5811
5812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5814 if (!SWIG_IsOK(res1)) {
5815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5816 }
5817 arg1 = reinterpret_cast< wxPoint * >(argp1);
5818 arg2 = obj1;
5819 {
5820 result = (bool)wxPoint___ne__(arg1,arg2);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 {
5824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5825 }
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj = 0;
5834 wxPoint *arg1 = (wxPoint *) 0 ;
5835 wxPoint *arg2 = 0 ;
5836 wxPoint result;
5837 void *argp1 = 0 ;
5838 int res1 = 0 ;
5839 wxPoint temp2 ;
5840 PyObject * obj0 = 0 ;
5841 PyObject * obj1 = 0 ;
5842 char * kwnames[] = {
5843 (char *) "self",(char *) "pt", NULL
5844 };
5845
5846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5848 if (!SWIG_IsOK(res1)) {
5849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5850 }
5851 arg1 = reinterpret_cast< wxPoint * >(argp1);
5852 {
5853 arg2 = &temp2;
5854 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5855 }
5856 {
5857 PyThreadState* __tstate = wxPyBeginAllowThreads();
5858 result = (arg1)->operator +((wxPoint const &)*arg2);
5859 wxPyEndAllowThreads(__tstate);
5860 if (PyErr_Occurred()) SWIG_fail;
5861 }
5862 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5863 return resultobj;
5864 fail:
5865 return NULL;
5866 }
5867
5868
5869 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5870 PyObject *resultobj = 0;
5871 wxPoint *arg1 = (wxPoint *) 0 ;
5872 wxPoint *arg2 = 0 ;
5873 wxPoint result;
5874 void *argp1 = 0 ;
5875 int res1 = 0 ;
5876 wxPoint temp2 ;
5877 PyObject * obj0 = 0 ;
5878 PyObject * obj1 = 0 ;
5879 char * kwnames[] = {
5880 (char *) "self",(char *) "pt", NULL
5881 };
5882
5883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5885 if (!SWIG_IsOK(res1)) {
5886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5887 }
5888 arg1 = reinterpret_cast< wxPoint * >(argp1);
5889 {
5890 arg2 = &temp2;
5891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5892 }
5893 {
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (arg1)->operator -((wxPoint const &)*arg2);
5896 wxPyEndAllowThreads(__tstate);
5897 if (PyErr_Occurred()) SWIG_fail;
5898 }
5899 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5900 return resultobj;
5901 fail:
5902 return NULL;
5903 }
5904
5905
5906 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj = 0;
5908 wxPoint *arg1 = (wxPoint *) 0 ;
5909 wxPoint *arg2 = 0 ;
5910 wxPoint *result = 0 ;
5911 void *argp1 = 0 ;
5912 int res1 = 0 ;
5913 wxPoint temp2 ;
5914 PyObject * obj0 = 0 ;
5915 PyObject * obj1 = 0 ;
5916 char * kwnames[] = {
5917 (char *) "self",(char *) "pt", NULL
5918 };
5919
5920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5922 if (!SWIG_IsOK(res1)) {
5923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5924 }
5925 arg1 = reinterpret_cast< wxPoint * >(argp1);
5926 {
5927 arg2 = &temp2;
5928 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5929 }
5930 {
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 {
5933 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5934 result = (wxPoint *) &_result_ref;
5935 }
5936 wxPyEndAllowThreads(__tstate);
5937 if (PyErr_Occurred()) SWIG_fail;
5938 }
5939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5940 return resultobj;
5941 fail:
5942 return NULL;
5943 }
5944
5945
5946 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5947 PyObject *resultobj = 0;
5948 wxPoint *arg1 = (wxPoint *) 0 ;
5949 wxPoint *arg2 = 0 ;
5950 wxPoint *result = 0 ;
5951 void *argp1 = 0 ;
5952 int res1 = 0 ;
5953 wxPoint temp2 ;
5954 PyObject * obj0 = 0 ;
5955 PyObject * obj1 = 0 ;
5956 char * kwnames[] = {
5957 (char *) "self",(char *) "pt", NULL
5958 };
5959
5960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5962 if (!SWIG_IsOK(res1)) {
5963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5964 }
5965 arg1 = reinterpret_cast< wxPoint * >(argp1);
5966 {
5967 arg2 = &temp2;
5968 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5969 }
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 {
5973 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5974 result = (wxPoint *) &_result_ref;
5975 }
5976 wxPyEndAllowThreads(__tstate);
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj = 0;
5988 wxPoint *arg1 = (wxPoint *) 0 ;
5989 long arg2 ;
5990 long arg3 ;
5991 void *argp1 = 0 ;
5992 int res1 = 0 ;
5993 long val2 ;
5994 int ecode2 = 0 ;
5995 long val3 ;
5996 int ecode3 = 0 ;
5997 PyObject * obj0 = 0 ;
5998 PyObject * obj1 = 0 ;
5999 PyObject * obj2 = 0 ;
6000 char * kwnames[] = {
6001 (char *) "self",(char *) "x",(char *) "y", NULL
6002 };
6003
6004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6006 if (!SWIG_IsOK(res1)) {
6007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6008 }
6009 arg1 = reinterpret_cast< wxPoint * >(argp1);
6010 ecode2 = SWIG_AsVal_long(obj1, &val2);
6011 if (!SWIG_IsOK(ecode2)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6013 }
6014 arg2 = static_cast< long >(val2);
6015 ecode3 = SWIG_AsVal_long(obj2, &val3);
6016 if (!SWIG_IsOK(ecode3)) {
6017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6018 }
6019 arg3 = static_cast< long >(val3);
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 wxPoint_Set(arg1,arg2,arg3);
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_Py_Void();
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6034 PyObject *resultobj = 0;
6035 wxPoint *arg1 = (wxPoint *) 0 ;
6036 PyObject *result = 0 ;
6037 void *argp1 = 0 ;
6038 int res1 = 0 ;
6039 PyObject *swig_obj[1] ;
6040
6041 if (!args) SWIG_fail;
6042 swig_obj[0] = args;
6043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6044 if (!SWIG_IsOK(res1)) {
6045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6046 }
6047 arg1 = reinterpret_cast< wxPoint * >(argp1);
6048 {
6049 PyThreadState* __tstate = wxPyBeginAllowThreads();
6050 result = (PyObject *)wxPoint_Get(arg1);
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 resultobj = result;
6055 return resultobj;
6056 fail:
6057 return NULL;
6058 }
6059
6060
6061 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6062 PyObject *obj;
6063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6064 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6065 return SWIG_Py_Void();
6066 }
6067
6068 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6069 return SWIG_Python_InitShadowInstance(args);
6070 }
6071
6072 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj = 0;
6074 int arg1 = (int) 0 ;
6075 int arg2 = (int) 0 ;
6076 int arg3 = (int) 0 ;
6077 int arg4 = (int) 0 ;
6078 wxRect *result = 0 ;
6079 int val1 ;
6080 int ecode1 = 0 ;
6081 int val2 ;
6082 int ecode2 = 0 ;
6083 int val3 ;
6084 int ecode3 = 0 ;
6085 int val4 ;
6086 int ecode4 = 0 ;
6087 PyObject * obj0 = 0 ;
6088 PyObject * obj1 = 0 ;
6089 PyObject * obj2 = 0 ;
6090 PyObject * obj3 = 0 ;
6091 char * kwnames[] = {
6092 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6093 };
6094
6095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6096 if (obj0) {
6097 ecode1 = SWIG_AsVal_int(obj0, &val1);
6098 if (!SWIG_IsOK(ecode1)) {
6099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6100 }
6101 arg1 = static_cast< int >(val1);
6102 }
6103 if (obj1) {
6104 ecode2 = SWIG_AsVal_int(obj1, &val2);
6105 if (!SWIG_IsOK(ecode2)) {
6106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6107 }
6108 arg2 = static_cast< int >(val2);
6109 }
6110 if (obj2) {
6111 ecode3 = SWIG_AsVal_int(obj2, &val3);
6112 if (!SWIG_IsOK(ecode3)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6114 }
6115 arg3 = static_cast< int >(val3);
6116 }
6117 if (obj3) {
6118 ecode4 = SWIG_AsVal_int(obj3, &val4);
6119 if (!SWIG_IsOK(ecode4)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6121 }
6122 arg4 = static_cast< int >(val4);
6123 }
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6127 wxPyEndAllowThreads(__tstate);
6128 if (PyErr_Occurred()) SWIG_fail;
6129 }
6130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj = 0;
6139 wxPoint *arg1 = 0 ;
6140 wxPoint *arg2 = 0 ;
6141 wxRect *result = 0 ;
6142 wxPoint temp1 ;
6143 wxPoint temp2 ;
6144 PyObject * obj0 = 0 ;
6145 PyObject * obj1 = 0 ;
6146 char * kwnames[] = {
6147 (char *) "topLeft",(char *) "bottomRight", NULL
6148 };
6149
6150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6151 {
6152 arg1 = &temp1;
6153 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6154 }
6155 {
6156 arg2 = &temp2;
6157 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6158 }
6159 {
6160 PyThreadState* __tstate = wxPyBeginAllowThreads();
6161 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj = 0;
6174 wxPoint *arg1 = 0 ;
6175 wxSize *arg2 = 0 ;
6176 wxRect *result = 0 ;
6177 wxPoint temp1 ;
6178 wxSize temp2 ;
6179 PyObject * obj0 = 0 ;
6180 PyObject * obj1 = 0 ;
6181 char * kwnames[] = {
6182 (char *) "pos",(char *) "size", NULL
6183 };
6184
6185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6186 {
6187 arg1 = &temp1;
6188 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6189 }
6190 {
6191 arg2 = &temp2;
6192 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6193 }
6194 {
6195 PyThreadState* __tstate = wxPyBeginAllowThreads();
6196 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6201 return resultobj;
6202 fail:
6203 return NULL;
6204 }
6205
6206
6207 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj = 0;
6209 wxSize *arg1 = 0 ;
6210 wxRect *result = 0 ;
6211 wxSize temp1 ;
6212 PyObject * obj0 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "size", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6218 {
6219 arg1 = &temp1;
6220 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6221 }
6222 {
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6236 PyObject *resultobj = 0;
6237 wxRect *arg1 = (wxRect *) 0 ;
6238 void *argp1 = 0 ;
6239 int res1 = 0 ;
6240 PyObject *swig_obj[1] ;
6241
6242 if (!args) SWIG_fail;
6243 swig_obj[0] = args;
6244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6245 if (!SWIG_IsOK(res1)) {
6246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6247 }
6248 arg1 = reinterpret_cast< wxRect * >(argp1);
6249 {
6250 PyThreadState* __tstate = wxPyBeginAllowThreads();
6251 delete arg1;
6252
6253 wxPyEndAllowThreads(__tstate);
6254 if (PyErr_Occurred()) SWIG_fail;
6255 }
6256 resultobj = SWIG_Py_Void();
6257 return resultobj;
6258 fail:
6259 return NULL;
6260 }
6261
6262
6263 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6264 PyObject *resultobj = 0;
6265 wxRect *arg1 = (wxRect *) 0 ;
6266 int result;
6267 void *argp1 = 0 ;
6268 int res1 = 0 ;
6269 PyObject *swig_obj[1] ;
6270
6271 if (!args) SWIG_fail;
6272 swig_obj[0] = args;
6273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6274 if (!SWIG_IsOK(res1)) {
6275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6276 }
6277 arg1 = reinterpret_cast< wxRect * >(argp1);
6278 {
6279 PyThreadState* __tstate = wxPyBeginAllowThreads();
6280 result = (int)((wxRect const *)arg1)->GetX();
6281 wxPyEndAllowThreads(__tstate);
6282 if (PyErr_Occurred()) SWIG_fail;
6283 }
6284 resultobj = SWIG_From_int(static_cast< int >(result));
6285 return resultobj;
6286 fail:
6287 return NULL;
6288 }
6289
6290
6291 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6292 PyObject *resultobj = 0;
6293 wxRect *arg1 = (wxRect *) 0 ;
6294 int arg2 ;
6295 void *argp1 = 0 ;
6296 int res1 = 0 ;
6297 int val2 ;
6298 int ecode2 = 0 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char * kwnames[] = {
6302 (char *) "self",(char *) "x", NULL
6303 };
6304
6305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6307 if (!SWIG_IsOK(res1)) {
6308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6309 }
6310 arg1 = reinterpret_cast< wxRect * >(argp1);
6311 ecode2 = SWIG_AsVal_int(obj1, &val2);
6312 if (!SWIG_IsOK(ecode2)) {
6313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6314 }
6315 arg2 = static_cast< int >(val2);
6316 {
6317 PyThreadState* __tstate = wxPyBeginAllowThreads();
6318 (arg1)->SetX(arg2);
6319 wxPyEndAllowThreads(__tstate);
6320 if (PyErr_Occurred()) SWIG_fail;
6321 }
6322 resultobj = SWIG_Py_Void();
6323 return resultobj;
6324 fail:
6325 return NULL;
6326 }
6327
6328
6329 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6330 PyObject *resultobj = 0;
6331 wxRect *arg1 = (wxRect *) 0 ;
6332 int result;
6333 void *argp1 = 0 ;
6334 int res1 = 0 ;
6335 PyObject *swig_obj[1] ;
6336
6337 if (!args) SWIG_fail;
6338 swig_obj[0] = args;
6339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6340 if (!SWIG_IsOK(res1)) {
6341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6342 }
6343 arg1 = reinterpret_cast< wxRect * >(argp1);
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 result = (int)(arg1)->GetY();
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 resultobj = SWIG_From_int(static_cast< int >(result));
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj = 0;
6359 wxRect *arg1 = (wxRect *) 0 ;
6360 int arg2 ;
6361 void *argp1 = 0 ;
6362 int res1 = 0 ;
6363 int val2 ;
6364 int ecode2 = 0 ;
6365 PyObject * obj0 = 0 ;
6366 PyObject * obj1 = 0 ;
6367 char * kwnames[] = {
6368 (char *) "self",(char *) "y", NULL
6369 };
6370
6371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6373 if (!SWIG_IsOK(res1)) {
6374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6375 }
6376 arg1 = reinterpret_cast< wxRect * >(argp1);
6377 ecode2 = SWIG_AsVal_int(obj1, &val2);
6378 if (!SWIG_IsOK(ecode2)) {
6379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6380 }
6381 arg2 = static_cast< int >(val2);
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 (arg1)->SetY(arg2);
6385 wxPyEndAllowThreads(__tstate);
6386 if (PyErr_Occurred()) SWIG_fail;
6387 }
6388 resultobj = SWIG_Py_Void();
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6396 PyObject *resultobj = 0;
6397 wxRect *arg1 = (wxRect *) 0 ;
6398 int result;
6399 void *argp1 = 0 ;
6400 int res1 = 0 ;
6401 PyObject *swig_obj[1] ;
6402
6403 if (!args) SWIG_fail;
6404 swig_obj[0] = args;
6405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6406 if (!SWIG_IsOK(res1)) {
6407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6408 }
6409 arg1 = reinterpret_cast< wxRect * >(argp1);
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (int)((wxRect const *)arg1)->GetWidth();
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 resultobj = SWIG_From_int(static_cast< int >(result));
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj = 0;
6425 wxRect *arg1 = (wxRect *) 0 ;
6426 int arg2 ;
6427 void *argp1 = 0 ;
6428 int res1 = 0 ;
6429 int val2 ;
6430 int ecode2 = 0 ;
6431 PyObject * obj0 = 0 ;
6432 PyObject * obj1 = 0 ;
6433 char * kwnames[] = {
6434 (char *) "self",(char *) "w", NULL
6435 };
6436
6437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6439 if (!SWIG_IsOK(res1)) {
6440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6441 }
6442 arg1 = reinterpret_cast< wxRect * >(argp1);
6443 ecode2 = SWIG_AsVal_int(obj1, &val2);
6444 if (!SWIG_IsOK(ecode2)) {
6445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6446 }
6447 arg2 = static_cast< int >(val2);
6448 {
6449 PyThreadState* __tstate = wxPyBeginAllowThreads();
6450 (arg1)->SetWidth(arg2);
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_Py_Void();
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6462 PyObject *resultobj = 0;
6463 wxRect *arg1 = (wxRect *) 0 ;
6464 int result;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 PyObject *swig_obj[1] ;
6468
6469 if (!args) SWIG_fail;
6470 swig_obj[0] = args;
6471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6474 }
6475 arg1 = reinterpret_cast< wxRect * >(argp1);
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (int)((wxRect const *)arg1)->GetHeight();
6479 wxPyEndAllowThreads(__tstate);
6480 if (PyErr_Occurred()) SWIG_fail;
6481 }
6482 resultobj = SWIG_From_int(static_cast< int >(result));
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj = 0;
6491 wxRect *arg1 = (wxRect *) 0 ;
6492 int arg2 ;
6493 void *argp1 = 0 ;
6494 int res1 = 0 ;
6495 int val2 ;
6496 int ecode2 = 0 ;
6497 PyObject * obj0 = 0 ;
6498 PyObject * obj1 = 0 ;
6499 char * kwnames[] = {
6500 (char *) "self",(char *) "h", NULL
6501 };
6502
6503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6505 if (!SWIG_IsOK(res1)) {
6506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6507 }
6508 arg1 = reinterpret_cast< wxRect * >(argp1);
6509 ecode2 = SWIG_AsVal_int(obj1, &val2);
6510 if (!SWIG_IsOK(ecode2)) {
6511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6512 }
6513 arg2 = static_cast< int >(val2);
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 (arg1)->SetHeight(arg2);
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 resultobj = SWIG_Py_Void();
6521 return resultobj;
6522 fail:
6523 return NULL;
6524 }
6525
6526
6527 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6528 PyObject *resultobj = 0;
6529 wxRect *arg1 = (wxRect *) 0 ;
6530 wxPoint result;
6531 void *argp1 = 0 ;
6532 int res1 = 0 ;
6533 PyObject *swig_obj[1] ;
6534
6535 if (!args) SWIG_fail;
6536 swig_obj[0] = args;
6537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6538 if (!SWIG_IsOK(res1)) {
6539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6540 }
6541 arg1 = reinterpret_cast< wxRect * >(argp1);
6542 {
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 result = ((wxRect const *)arg1)->GetPosition();
6545 wxPyEndAllowThreads(__tstate);
6546 if (PyErr_Occurred()) SWIG_fail;
6547 }
6548 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6549 return resultobj;
6550 fail:
6551 return NULL;
6552 }
6553
6554
6555 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj = 0;
6557 wxRect *arg1 = (wxRect *) 0 ;
6558 wxPoint *arg2 = 0 ;
6559 void *argp1 = 0 ;
6560 int res1 = 0 ;
6561 wxPoint temp2 ;
6562 PyObject * obj0 = 0 ;
6563 PyObject * obj1 = 0 ;
6564 char * kwnames[] = {
6565 (char *) "self",(char *) "p", NULL
6566 };
6567
6568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6570 if (!SWIG_IsOK(res1)) {
6571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6572 }
6573 arg1 = reinterpret_cast< wxRect * >(argp1);
6574 {
6575 arg2 = &temp2;
6576 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6577 }
6578 {
6579 PyThreadState* __tstate = wxPyBeginAllowThreads();
6580 (arg1)->SetPosition((wxPoint const &)*arg2);
6581 wxPyEndAllowThreads(__tstate);
6582 if (PyErr_Occurred()) SWIG_fail;
6583 }
6584 resultobj = SWIG_Py_Void();
6585 return resultobj;
6586 fail:
6587 return NULL;
6588 }
6589
6590
6591 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6592 PyObject *resultobj = 0;
6593 wxRect *arg1 = (wxRect *) 0 ;
6594 wxSize result;
6595 void *argp1 = 0 ;
6596 int res1 = 0 ;
6597 PyObject *swig_obj[1] ;
6598
6599 if (!args) SWIG_fail;
6600 swig_obj[0] = args;
6601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6602 if (!SWIG_IsOK(res1)) {
6603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6604 }
6605 arg1 = reinterpret_cast< wxRect * >(argp1);
6606 {
6607 PyThreadState* __tstate = wxPyBeginAllowThreads();
6608 result = ((wxRect const *)arg1)->GetSize();
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj = 0;
6621 wxRect *arg1 = (wxRect *) 0 ;
6622 wxSize *arg2 = 0 ;
6623 void *argp1 = 0 ;
6624 int res1 = 0 ;
6625 wxSize temp2 ;
6626 PyObject * obj0 = 0 ;
6627 PyObject * obj1 = 0 ;
6628 char * kwnames[] = {
6629 (char *) "self",(char *) "s", NULL
6630 };
6631
6632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6634 if (!SWIG_IsOK(res1)) {
6635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6636 }
6637 arg1 = reinterpret_cast< wxRect * >(argp1);
6638 {
6639 arg2 = &temp2;
6640 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6641 }
6642 {
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 (arg1)->SetSize((wxSize const &)*arg2);
6645 wxPyEndAllowThreads(__tstate);
6646 if (PyErr_Occurred()) SWIG_fail;
6647 }
6648 resultobj = SWIG_Py_Void();
6649 return resultobj;
6650 fail:
6651 return NULL;
6652 }
6653
6654
6655 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6656 PyObject *resultobj = 0;
6657 wxRect *arg1 = (wxRect *) 0 ;
6658 bool result;
6659 void *argp1 = 0 ;
6660 int res1 = 0 ;
6661 PyObject *swig_obj[1] ;
6662
6663 if (!args) SWIG_fail;
6664 swig_obj[0] = args;
6665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6666 if (!SWIG_IsOK(res1)) {
6667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6668 }
6669 arg1 = reinterpret_cast< wxRect * >(argp1);
6670 {
6671 PyThreadState* __tstate = wxPyBeginAllowThreads();
6672 result = (bool)((wxRect const *)arg1)->IsEmpty();
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 {
6677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6678 }
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6686 PyObject *resultobj = 0;
6687 wxRect *arg1 = (wxRect *) 0 ;
6688 wxPoint result;
6689 void *argp1 = 0 ;
6690 int res1 = 0 ;
6691 PyObject *swig_obj[1] ;
6692
6693 if (!args) SWIG_fail;
6694 swig_obj[0] = args;
6695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6696 if (!SWIG_IsOK(res1)) {
6697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6698 }
6699 arg1 = reinterpret_cast< wxRect * >(argp1);
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = ((wxRect const *)arg1)->GetTopLeft();
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj = 0;
6715 wxRect *arg1 = (wxRect *) 0 ;
6716 wxPoint *arg2 = 0 ;
6717 void *argp1 = 0 ;
6718 int res1 = 0 ;
6719 wxPoint temp2 ;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 char * kwnames[] = {
6723 (char *) "self",(char *) "p", NULL
6724 };
6725
6726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6728 if (!SWIG_IsOK(res1)) {
6729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6730 }
6731 arg1 = reinterpret_cast< wxRect * >(argp1);
6732 {
6733 arg2 = &temp2;
6734 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6735 }
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 resultobj = SWIG_Py_Void();
6743 return resultobj;
6744 fail:
6745 return NULL;
6746 }
6747
6748
6749 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6750 PyObject *resultobj = 0;
6751 wxRect *arg1 = (wxRect *) 0 ;
6752 wxPoint result;
6753 void *argp1 = 0 ;
6754 int res1 = 0 ;
6755 PyObject *swig_obj[1] ;
6756
6757 if (!args) SWIG_fail;
6758 swig_obj[0] = args;
6759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6760 if (!SWIG_IsOK(res1)) {
6761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6762 }
6763 arg1 = reinterpret_cast< wxRect * >(argp1);
6764 {
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 result = ((wxRect const *)arg1)->GetBottomRight();
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6778 PyObject *resultobj = 0;
6779 wxRect *arg1 = (wxRect *) 0 ;
6780 wxPoint *arg2 = 0 ;
6781 void *argp1 = 0 ;
6782 int res1 = 0 ;
6783 wxPoint temp2 ;
6784 PyObject * obj0 = 0 ;
6785 PyObject * obj1 = 0 ;
6786 char * kwnames[] = {
6787 (char *) "self",(char *) "p", NULL
6788 };
6789
6790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6792 if (!SWIG_IsOK(res1)) {
6793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6794 }
6795 arg1 = reinterpret_cast< wxRect * >(argp1);
6796 {
6797 arg2 = &temp2;
6798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6799 }
6800 {
6801 PyThreadState* __tstate = wxPyBeginAllowThreads();
6802 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 resultobj = SWIG_Py_Void();
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6814 PyObject *resultobj = 0;
6815 wxRect *arg1 = (wxRect *) 0 ;
6816 int result;
6817 void *argp1 = 0 ;
6818 int res1 = 0 ;
6819 PyObject *swig_obj[1] ;
6820
6821 if (!args) SWIG_fail;
6822 swig_obj[0] = args;
6823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6824 if (!SWIG_IsOK(res1)) {
6825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6826 }
6827 arg1 = reinterpret_cast< wxRect * >(argp1);
6828 {
6829 PyThreadState* __tstate = wxPyBeginAllowThreads();
6830 result = (int)((wxRect const *)arg1)->GetLeft();
6831 wxPyEndAllowThreads(__tstate);
6832 if (PyErr_Occurred()) SWIG_fail;
6833 }
6834 resultobj = SWIG_From_int(static_cast< int >(result));
6835 return resultobj;
6836 fail:
6837 return NULL;
6838 }
6839
6840
6841 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6842 PyObject *resultobj = 0;
6843 wxRect *arg1 = (wxRect *) 0 ;
6844 int result;
6845 void *argp1 = 0 ;
6846 int res1 = 0 ;
6847 PyObject *swig_obj[1] ;
6848
6849 if (!args) SWIG_fail;
6850 swig_obj[0] = args;
6851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6852 if (!SWIG_IsOK(res1)) {
6853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6854 }
6855 arg1 = reinterpret_cast< wxRect * >(argp1);
6856 {
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 result = (int)((wxRect const *)arg1)->GetTop();
6859 wxPyEndAllowThreads(__tstate);
6860 if (PyErr_Occurred()) SWIG_fail;
6861 }
6862 resultobj = SWIG_From_int(static_cast< int >(result));
6863 return resultobj;
6864 fail:
6865 return NULL;
6866 }
6867
6868
6869 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6870 PyObject *resultobj = 0;
6871 wxRect *arg1 = (wxRect *) 0 ;
6872 int result;
6873 void *argp1 = 0 ;
6874 int res1 = 0 ;
6875 PyObject *swig_obj[1] ;
6876
6877 if (!args) SWIG_fail;
6878 swig_obj[0] = args;
6879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6880 if (!SWIG_IsOK(res1)) {
6881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6882 }
6883 arg1 = reinterpret_cast< wxRect * >(argp1);
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 result = (int)((wxRect const *)arg1)->GetBottom();
6887 wxPyEndAllowThreads(__tstate);
6888 if (PyErr_Occurred()) SWIG_fail;
6889 }
6890 resultobj = SWIG_From_int(static_cast< int >(result));
6891 return resultobj;
6892 fail:
6893 return NULL;
6894 }
6895
6896
6897 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6898 PyObject *resultobj = 0;
6899 wxRect *arg1 = (wxRect *) 0 ;
6900 int result;
6901 void *argp1 = 0 ;
6902 int res1 = 0 ;
6903 PyObject *swig_obj[1] ;
6904
6905 if (!args) SWIG_fail;
6906 swig_obj[0] = args;
6907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6908 if (!SWIG_IsOK(res1)) {
6909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6910 }
6911 arg1 = reinterpret_cast< wxRect * >(argp1);
6912 {
6913 PyThreadState* __tstate = wxPyBeginAllowThreads();
6914 result = (int)((wxRect const *)arg1)->GetRight();
6915 wxPyEndAllowThreads(__tstate);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 resultobj = SWIG_From_int(static_cast< int >(result));
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6926 PyObject *resultobj = 0;
6927 wxRect *arg1 = (wxRect *) 0 ;
6928 int arg2 ;
6929 void *argp1 = 0 ;
6930 int res1 = 0 ;
6931 int val2 ;
6932 int ecode2 = 0 ;
6933 PyObject * obj0 = 0 ;
6934 PyObject * obj1 = 0 ;
6935 char * kwnames[] = {
6936 (char *) "self",(char *) "left", NULL
6937 };
6938
6939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6941 if (!SWIG_IsOK(res1)) {
6942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6943 }
6944 arg1 = reinterpret_cast< wxRect * >(argp1);
6945 ecode2 = SWIG_AsVal_int(obj1, &val2);
6946 if (!SWIG_IsOK(ecode2)) {
6947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6948 }
6949 arg2 = static_cast< int >(val2);
6950 {
6951 PyThreadState* __tstate = wxPyBeginAllowThreads();
6952 (arg1)->SetLeft(arg2);
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_Py_Void();
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj = 0;
6965 wxRect *arg1 = (wxRect *) 0 ;
6966 int arg2 ;
6967 void *argp1 = 0 ;
6968 int res1 = 0 ;
6969 int val2 ;
6970 int ecode2 = 0 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char * kwnames[] = {
6974 (char *) "self",(char *) "right", NULL
6975 };
6976
6977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6979 if (!SWIG_IsOK(res1)) {
6980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6981 }
6982 arg1 = reinterpret_cast< wxRect * >(argp1);
6983 ecode2 = SWIG_AsVal_int(obj1, &val2);
6984 if (!SWIG_IsOK(ecode2)) {
6985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6986 }
6987 arg2 = static_cast< int >(val2);
6988 {
6989 PyThreadState* __tstate = wxPyBeginAllowThreads();
6990 (arg1)->SetRight(arg2);
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_Py_Void();
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7002 PyObject *resultobj = 0;
7003 wxRect *arg1 = (wxRect *) 0 ;
7004 int arg2 ;
7005 void *argp1 = 0 ;
7006 int res1 = 0 ;
7007 int val2 ;
7008 int ecode2 = 0 ;
7009 PyObject * obj0 = 0 ;
7010 PyObject * obj1 = 0 ;
7011 char * kwnames[] = {
7012 (char *) "self",(char *) "top", NULL
7013 };
7014
7015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7017 if (!SWIG_IsOK(res1)) {
7018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7019 }
7020 arg1 = reinterpret_cast< wxRect * >(argp1);
7021 ecode2 = SWIG_AsVal_int(obj1, &val2);
7022 if (!SWIG_IsOK(ecode2)) {
7023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7024 }
7025 arg2 = static_cast< int >(val2);
7026 {
7027 PyThreadState* __tstate = wxPyBeginAllowThreads();
7028 (arg1)->SetTop(arg2);
7029 wxPyEndAllowThreads(__tstate);
7030 if (PyErr_Occurred()) SWIG_fail;
7031 }
7032 resultobj = SWIG_Py_Void();
7033 return resultobj;
7034 fail:
7035 return NULL;
7036 }
7037
7038
7039 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7040 PyObject *resultobj = 0;
7041 wxRect *arg1 = (wxRect *) 0 ;
7042 int arg2 ;
7043 void *argp1 = 0 ;
7044 int res1 = 0 ;
7045 int val2 ;
7046 int ecode2 = 0 ;
7047 PyObject * obj0 = 0 ;
7048 PyObject * obj1 = 0 ;
7049 char * kwnames[] = {
7050 (char *) "self",(char *) "bottom", NULL
7051 };
7052
7053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7055 if (!SWIG_IsOK(res1)) {
7056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7057 }
7058 arg1 = reinterpret_cast< wxRect * >(argp1);
7059 ecode2 = SWIG_AsVal_int(obj1, &val2);
7060 if (!SWIG_IsOK(ecode2)) {
7061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7062 }
7063 arg2 = static_cast< int >(val2);
7064 {
7065 PyThreadState* __tstate = wxPyBeginAllowThreads();
7066 (arg1)->SetBottom(arg2);
7067 wxPyEndAllowThreads(__tstate);
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 resultobj = SWIG_Py_Void();
7071 return resultobj;
7072 fail:
7073 return NULL;
7074 }
7075
7076
7077 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7078 PyObject *resultobj = 0;
7079 wxRect *arg1 = (wxRect *) 0 ;
7080 int arg2 ;
7081 int arg3 ;
7082 wxRect *result = 0 ;
7083 void *argp1 = 0 ;
7084 int res1 = 0 ;
7085 int val2 ;
7086 int ecode2 = 0 ;
7087 int val3 ;
7088 int ecode3 = 0 ;
7089 PyObject * obj0 = 0 ;
7090 PyObject * obj1 = 0 ;
7091 PyObject * obj2 = 0 ;
7092 char * kwnames[] = {
7093 (char *) "self",(char *) "dx",(char *) "dy", NULL
7094 };
7095
7096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7098 if (!SWIG_IsOK(res1)) {
7099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7100 }
7101 arg1 = reinterpret_cast< wxRect * >(argp1);
7102 ecode2 = SWIG_AsVal_int(obj1, &val2);
7103 if (!SWIG_IsOK(ecode2)) {
7104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7105 }
7106 arg2 = static_cast< int >(val2);
7107 ecode3 = SWIG_AsVal_int(obj2, &val3);
7108 if (!SWIG_IsOK(ecode3)) {
7109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7110 }
7111 arg3 = static_cast< int >(val3);
7112 {
7113 PyThreadState* __tstate = wxPyBeginAllowThreads();
7114 {
7115 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7116 result = (wxRect *) &_result_ref;
7117 }
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj = 0;
7130 wxRect *arg1 = (wxRect *) 0 ;
7131 int arg2 ;
7132 int arg3 ;
7133 wxRect *result = 0 ;
7134 void *argp1 = 0 ;
7135 int res1 = 0 ;
7136 int val2 ;
7137 int ecode2 = 0 ;
7138 int val3 ;
7139 int ecode3 = 0 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 PyObject * obj2 = 0 ;
7143 char * kwnames[] = {
7144 (char *) "self",(char *) "dx",(char *) "dy", NULL
7145 };
7146
7147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7149 if (!SWIG_IsOK(res1)) {
7150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7151 }
7152 arg1 = reinterpret_cast< wxRect * >(argp1);
7153 ecode2 = SWIG_AsVal_int(obj1, &val2);
7154 if (!SWIG_IsOK(ecode2)) {
7155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7156 }
7157 arg2 = static_cast< int >(val2);
7158 ecode3 = SWIG_AsVal_int(obj2, &val3);
7159 if (!SWIG_IsOK(ecode3)) {
7160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7161 }
7162 arg3 = static_cast< int >(val3);
7163 {
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 {
7166 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7167 result = (wxRect *) &_result_ref;
7168 }
7169 wxPyEndAllowThreads(__tstate);
7170 if (PyErr_Occurred()) SWIG_fail;
7171 }
7172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj = 0;
7181 wxRect *arg1 = (wxRect *) 0 ;
7182 int arg2 ;
7183 int arg3 ;
7184 void *argp1 = 0 ;
7185 int res1 = 0 ;
7186 int val2 ;
7187 int ecode2 = 0 ;
7188 int val3 ;
7189 int ecode3 = 0 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 PyObject * obj2 = 0 ;
7193 char * kwnames[] = {
7194 (char *) "self",(char *) "dx",(char *) "dy", NULL
7195 };
7196
7197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7199 if (!SWIG_IsOK(res1)) {
7200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7201 }
7202 arg1 = reinterpret_cast< wxRect * >(argp1);
7203 ecode2 = SWIG_AsVal_int(obj1, &val2);
7204 if (!SWIG_IsOK(ecode2)) {
7205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7206 }
7207 arg2 = static_cast< int >(val2);
7208 ecode3 = SWIG_AsVal_int(obj2, &val3);
7209 if (!SWIG_IsOK(ecode3)) {
7210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7211 }
7212 arg3 = static_cast< int >(val3);
7213 {
7214 PyThreadState* __tstate = wxPyBeginAllowThreads();
7215 (arg1)->Offset(arg2,arg3);
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 resultobj = SWIG_Py_Void();
7220 return resultobj;
7221 fail:
7222 return NULL;
7223 }
7224
7225
7226 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7227 PyObject *resultobj = 0;
7228 wxRect *arg1 = (wxRect *) 0 ;
7229 wxPoint *arg2 = 0 ;
7230 void *argp1 = 0 ;
7231 int res1 = 0 ;
7232 wxPoint temp2 ;
7233 PyObject * obj0 = 0 ;
7234 PyObject * obj1 = 0 ;
7235 char * kwnames[] = {
7236 (char *) "self",(char *) "pt", NULL
7237 };
7238
7239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7243 }
7244 arg1 = reinterpret_cast< wxRect * >(argp1);
7245 {
7246 arg2 = &temp2;
7247 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7248 }
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 (arg1)->Offset((wxPoint const &)*arg2);
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 resultobj = SWIG_Py_Void();
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj = 0;
7264 wxRect *arg1 = (wxRect *) 0 ;
7265 wxRect *arg2 = 0 ;
7266 wxRect result;
7267 void *argp1 = 0 ;
7268 int res1 = 0 ;
7269 wxRect temp2 ;
7270 PyObject * obj0 = 0 ;
7271 PyObject * obj1 = 0 ;
7272 char * kwnames[] = {
7273 (char *) "self",(char *) "rect", NULL
7274 };
7275
7276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7280 }
7281 arg1 = reinterpret_cast< wxRect * >(argp1);
7282 {
7283 arg2 = &temp2;
7284 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7285 }
7286 {
7287 PyThreadState* __tstate = wxPyBeginAllowThreads();
7288 result = (arg1)->Intersect((wxRect const &)*arg2);
7289 wxPyEndAllowThreads(__tstate);
7290 if (PyErr_Occurred()) SWIG_fail;
7291 }
7292 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7293 return resultobj;
7294 fail:
7295 return NULL;
7296 }
7297
7298
7299 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj = 0;
7301 wxRect *arg1 = (wxRect *) 0 ;
7302 wxRect *arg2 = 0 ;
7303 wxRect result;
7304 void *argp1 = 0 ;
7305 int res1 = 0 ;
7306 wxRect temp2 ;
7307 PyObject * obj0 = 0 ;
7308 PyObject * obj1 = 0 ;
7309 char * kwnames[] = {
7310 (char *) "self",(char *) "rect", NULL
7311 };
7312
7313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7315 if (!SWIG_IsOK(res1)) {
7316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7317 }
7318 arg1 = reinterpret_cast< wxRect * >(argp1);
7319 {
7320 arg2 = &temp2;
7321 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7322 }
7323 {
7324 PyThreadState* __tstate = wxPyBeginAllowThreads();
7325 result = (arg1)->Union((wxRect const &)*arg2);
7326 wxPyEndAllowThreads(__tstate);
7327 if (PyErr_Occurred()) SWIG_fail;
7328 }
7329 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7337 PyObject *resultobj = 0;
7338 wxRect *arg1 = (wxRect *) 0 ;
7339 wxRect *arg2 = 0 ;
7340 wxRect result;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 wxRect temp2 ;
7344 PyObject * obj0 = 0 ;
7345 PyObject * obj1 = 0 ;
7346 char * kwnames[] = {
7347 (char *) "self",(char *) "rect", NULL
7348 };
7349
7350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7352 if (!SWIG_IsOK(res1)) {
7353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7354 }
7355 arg1 = reinterpret_cast< wxRect * >(argp1);
7356 {
7357 arg2 = &temp2;
7358 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7359 }
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7363 wxPyEndAllowThreads(__tstate);
7364 if (PyErr_Occurred()) SWIG_fail;
7365 }
7366 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7367 return resultobj;
7368 fail:
7369 return NULL;
7370 }
7371
7372
7373 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7374 PyObject *resultobj = 0;
7375 wxRect *arg1 = (wxRect *) 0 ;
7376 wxRect *arg2 = 0 ;
7377 wxRect *result = 0 ;
7378 void *argp1 = 0 ;
7379 int res1 = 0 ;
7380 wxRect temp2 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "rect", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7391 }
7392 arg1 = reinterpret_cast< wxRect * >(argp1);
7393 {
7394 arg2 = &temp2;
7395 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7396 }
7397 {
7398 PyThreadState* __tstate = wxPyBeginAllowThreads();
7399 {
7400 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7401 result = (wxRect *) &_result_ref;
7402 }
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj = 0;
7415 wxRect *arg1 = (wxRect *) 0 ;
7416 PyObject *arg2 = (PyObject *) 0 ;
7417 bool result;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 PyObject * obj0 = 0 ;
7421 PyObject * obj1 = 0 ;
7422 char * kwnames[] = {
7423 (char *) "self",(char *) "other", NULL
7424 };
7425
7426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7428 if (!SWIG_IsOK(res1)) {
7429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7430 }
7431 arg1 = reinterpret_cast< wxRect * >(argp1);
7432 arg2 = obj1;
7433 {
7434 result = (bool)wxRect___eq__(arg1,arg2);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 {
7438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7439 }
7440 return resultobj;
7441 fail:
7442 return NULL;
7443 }
7444
7445
7446 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7447 PyObject *resultobj = 0;
7448 wxRect *arg1 = (wxRect *) 0 ;
7449 PyObject *arg2 = (PyObject *) 0 ;
7450 bool result;
7451 void *argp1 = 0 ;
7452 int res1 = 0 ;
7453 PyObject * obj0 = 0 ;
7454 PyObject * obj1 = 0 ;
7455 char * kwnames[] = {
7456 (char *) "self",(char *) "other", NULL
7457 };
7458
7459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7461 if (!SWIG_IsOK(res1)) {
7462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7463 }
7464 arg1 = reinterpret_cast< wxRect * >(argp1);
7465 arg2 = obj1;
7466 {
7467 result = (bool)wxRect___ne__(arg1,arg2);
7468 if (PyErr_Occurred()) SWIG_fail;
7469 }
7470 {
7471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7472 }
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7480 PyObject *resultobj = 0;
7481 wxRect *arg1 = (wxRect *) 0 ;
7482 int arg2 ;
7483 int arg3 ;
7484 bool result;
7485 void *argp1 = 0 ;
7486 int res1 = 0 ;
7487 int val2 ;
7488 int ecode2 = 0 ;
7489 int val3 ;
7490 int ecode3 = 0 ;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 PyObject * obj2 = 0 ;
7494 char * kwnames[] = {
7495 (char *) "self",(char *) "x",(char *) "y", NULL
7496 };
7497
7498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7500 if (!SWIG_IsOK(res1)) {
7501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7502 }
7503 arg1 = reinterpret_cast< wxRect * >(argp1);
7504 ecode2 = SWIG_AsVal_int(obj1, &val2);
7505 if (!SWIG_IsOK(ecode2)) {
7506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7507 }
7508 arg2 = static_cast< int >(val2);
7509 ecode3 = SWIG_AsVal_int(obj2, &val3);
7510 if (!SWIG_IsOK(ecode3)) {
7511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7512 }
7513 arg3 = static_cast< int >(val3);
7514 {
7515 PyThreadState* __tstate = wxPyBeginAllowThreads();
7516 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 {
7521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7522 }
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7530 PyObject *resultobj = 0;
7531 wxRect *arg1 = (wxRect *) 0 ;
7532 wxPoint *arg2 = 0 ;
7533 bool result;
7534 void *argp1 = 0 ;
7535 int res1 = 0 ;
7536 wxPoint temp2 ;
7537 PyObject * obj0 = 0 ;
7538 PyObject * obj1 = 0 ;
7539 char * kwnames[] = {
7540 (char *) "self",(char *) "pt", NULL
7541 };
7542
7543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7545 if (!SWIG_IsOK(res1)) {
7546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7547 }
7548 arg1 = reinterpret_cast< wxRect * >(argp1);
7549 {
7550 arg2 = &temp2;
7551 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7552 }
7553 {
7554 PyThreadState* __tstate = wxPyBeginAllowThreads();
7555 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7556 wxPyEndAllowThreads(__tstate);
7557 if (PyErr_Occurred()) SWIG_fail;
7558 }
7559 {
7560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7561 }
7562 return resultobj;
7563 fail:
7564 return NULL;
7565 }
7566
7567
7568 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7569 PyObject *resultobj = 0;
7570 wxRect *arg1 = (wxRect *) 0 ;
7571 wxRect *arg2 = 0 ;
7572 bool result;
7573 void *argp1 = 0 ;
7574 int res1 = 0 ;
7575 wxRect temp2 ;
7576 PyObject * obj0 = 0 ;
7577 PyObject * obj1 = 0 ;
7578 char * kwnames[] = {
7579 (char *) "self",(char *) "rect", NULL
7580 };
7581
7582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7584 if (!SWIG_IsOK(res1)) {
7585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7586 }
7587 arg1 = reinterpret_cast< wxRect * >(argp1);
7588 {
7589 arg2 = &temp2;
7590 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7591 }
7592 {
7593 PyThreadState* __tstate = wxPyBeginAllowThreads();
7594 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 {
7599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7600 }
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7608 PyObject *resultobj = 0;
7609 wxRect *arg1 = (wxRect *) 0 ;
7610 wxRect *arg2 = 0 ;
7611 bool result;
7612 void *argp1 = 0 ;
7613 int res1 = 0 ;
7614 wxRect temp2 ;
7615 PyObject * obj0 = 0 ;
7616 PyObject * obj1 = 0 ;
7617 char * kwnames[] = {
7618 (char *) "self",(char *) "rect", NULL
7619 };
7620
7621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7623 if (!SWIG_IsOK(res1)) {
7624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7625 }
7626 arg1 = reinterpret_cast< wxRect * >(argp1);
7627 {
7628 arg2 = &temp2;
7629 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7630 }
7631 {
7632 PyThreadState* __tstate = wxPyBeginAllowThreads();
7633 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 {
7638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7639 }
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7647 PyObject *resultobj = 0;
7648 wxRect *arg1 = (wxRect *) 0 ;
7649 wxRect *arg2 = 0 ;
7650 int arg3 = (int) wxBOTH ;
7651 wxRect result;
7652 void *argp1 = 0 ;
7653 int res1 = 0 ;
7654 wxRect temp2 ;
7655 int val3 ;
7656 int ecode3 = 0 ;
7657 PyObject * obj0 = 0 ;
7658 PyObject * obj1 = 0 ;
7659 PyObject * obj2 = 0 ;
7660 char * kwnames[] = {
7661 (char *) "self",(char *) "r",(char *) "dir", NULL
7662 };
7663
7664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7666 if (!SWIG_IsOK(res1)) {
7667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7668 }
7669 arg1 = reinterpret_cast< wxRect * >(argp1);
7670 {
7671 arg2 = &temp2;
7672 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7673 }
7674 if (obj2) {
7675 ecode3 = SWIG_AsVal_int(obj2, &val3);
7676 if (!SWIG_IsOK(ecode3)) {
7677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7678 }
7679 arg3 = static_cast< int >(val3);
7680 }
7681 {
7682 PyThreadState* __tstate = wxPyBeginAllowThreads();
7683 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7684 wxPyEndAllowThreads(__tstate);
7685 if (PyErr_Occurred()) SWIG_fail;
7686 }
7687 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7688 return resultobj;
7689 fail:
7690 return NULL;
7691 }
7692
7693
7694 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7695 PyObject *resultobj = 0;
7696 wxRect *arg1 = (wxRect *) 0 ;
7697 int arg2 ;
7698 void *argp1 = 0 ;
7699 int res1 = 0 ;
7700 int val2 ;
7701 int ecode2 = 0 ;
7702 PyObject *swig_obj[2] ;
7703
7704 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7706 if (!SWIG_IsOK(res1)) {
7707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7708 }
7709 arg1 = reinterpret_cast< wxRect * >(argp1);
7710 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7711 if (!SWIG_IsOK(ecode2)) {
7712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7713 }
7714 arg2 = static_cast< int >(val2);
7715 if (arg1) (arg1)->x = arg2;
7716
7717 resultobj = SWIG_Py_Void();
7718 return resultobj;
7719 fail:
7720 return NULL;
7721 }
7722
7723
7724 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7725 PyObject *resultobj = 0;
7726 wxRect *arg1 = (wxRect *) 0 ;
7727 int result;
7728 void *argp1 = 0 ;
7729 int res1 = 0 ;
7730 PyObject *swig_obj[1] ;
7731
7732 if (!args) SWIG_fail;
7733 swig_obj[0] = args;
7734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7735 if (!SWIG_IsOK(res1)) {
7736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7737 }
7738 arg1 = reinterpret_cast< wxRect * >(argp1);
7739 result = (int) ((arg1)->x);
7740 resultobj = SWIG_From_int(static_cast< int >(result));
7741 return resultobj;
7742 fail:
7743 return NULL;
7744 }
7745
7746
7747 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7748 PyObject *resultobj = 0;
7749 wxRect *arg1 = (wxRect *) 0 ;
7750 int arg2 ;
7751 void *argp1 = 0 ;
7752 int res1 = 0 ;
7753 int val2 ;
7754 int ecode2 = 0 ;
7755 PyObject *swig_obj[2] ;
7756
7757 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7761 }
7762 arg1 = reinterpret_cast< wxRect * >(argp1);
7763 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7764 if (!SWIG_IsOK(ecode2)) {
7765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7766 }
7767 arg2 = static_cast< int >(val2);
7768 if (arg1) (arg1)->y = arg2;
7769
7770 resultobj = SWIG_Py_Void();
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7778 PyObject *resultobj = 0;
7779 wxRect *arg1 = (wxRect *) 0 ;
7780 int result;
7781 void *argp1 = 0 ;
7782 int res1 = 0 ;
7783 PyObject *swig_obj[1] ;
7784
7785 if (!args) SWIG_fail;
7786 swig_obj[0] = args;
7787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7788 if (!SWIG_IsOK(res1)) {
7789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7790 }
7791 arg1 = reinterpret_cast< wxRect * >(argp1);
7792 result = (int) ((arg1)->y);
7793 resultobj = SWIG_From_int(static_cast< int >(result));
7794 return resultobj;
7795 fail:
7796 return NULL;
7797 }
7798
7799
7800 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7801 PyObject *resultobj = 0;
7802 wxRect *arg1 = (wxRect *) 0 ;
7803 int arg2 ;
7804 void *argp1 = 0 ;
7805 int res1 = 0 ;
7806 int val2 ;
7807 int ecode2 = 0 ;
7808 PyObject *swig_obj[2] ;
7809
7810 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7812 if (!SWIG_IsOK(res1)) {
7813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7814 }
7815 arg1 = reinterpret_cast< wxRect * >(argp1);
7816 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7817 if (!SWIG_IsOK(ecode2)) {
7818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7819 }
7820 arg2 = static_cast< int >(val2);
7821 if (arg1) (arg1)->width = arg2;
7822
7823 resultobj = SWIG_Py_Void();
7824 return resultobj;
7825 fail:
7826 return NULL;
7827 }
7828
7829
7830 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7831 PyObject *resultobj = 0;
7832 wxRect *arg1 = (wxRect *) 0 ;
7833 int result;
7834 void *argp1 = 0 ;
7835 int res1 = 0 ;
7836 PyObject *swig_obj[1] ;
7837
7838 if (!args) SWIG_fail;
7839 swig_obj[0] = args;
7840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7841 if (!SWIG_IsOK(res1)) {
7842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7843 }
7844 arg1 = reinterpret_cast< wxRect * >(argp1);
7845 result = (int) ((arg1)->width);
7846 resultobj = SWIG_From_int(static_cast< int >(result));
7847 return resultobj;
7848 fail:
7849 return NULL;
7850 }
7851
7852
7853 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7854 PyObject *resultobj = 0;
7855 wxRect *arg1 = (wxRect *) 0 ;
7856 int arg2 ;
7857 void *argp1 = 0 ;
7858 int res1 = 0 ;
7859 int val2 ;
7860 int ecode2 = 0 ;
7861 PyObject *swig_obj[2] ;
7862
7863 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7865 if (!SWIG_IsOK(res1)) {
7866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7867 }
7868 arg1 = reinterpret_cast< wxRect * >(argp1);
7869 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7870 if (!SWIG_IsOK(ecode2)) {
7871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7872 }
7873 arg2 = static_cast< int >(val2);
7874 if (arg1) (arg1)->height = arg2;
7875
7876 resultobj = SWIG_Py_Void();
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7884 PyObject *resultobj = 0;
7885 wxRect *arg1 = (wxRect *) 0 ;
7886 int result;
7887 void *argp1 = 0 ;
7888 int res1 = 0 ;
7889 PyObject *swig_obj[1] ;
7890
7891 if (!args) SWIG_fail;
7892 swig_obj[0] = args;
7893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7894 if (!SWIG_IsOK(res1)) {
7895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7896 }
7897 arg1 = reinterpret_cast< wxRect * >(argp1);
7898 result = (int) ((arg1)->height);
7899 resultobj = SWIG_From_int(static_cast< int >(result));
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7907 PyObject *resultobj = 0;
7908 wxRect *arg1 = (wxRect *) 0 ;
7909 int arg2 = (int) 0 ;
7910 int arg3 = (int) 0 ;
7911 int arg4 = (int) 0 ;
7912 int arg5 = (int) 0 ;
7913 void *argp1 = 0 ;
7914 int res1 = 0 ;
7915 int val2 ;
7916 int ecode2 = 0 ;
7917 int val3 ;
7918 int ecode3 = 0 ;
7919 int val4 ;
7920 int ecode4 = 0 ;
7921 int val5 ;
7922 int ecode5 = 0 ;
7923 PyObject * obj0 = 0 ;
7924 PyObject * obj1 = 0 ;
7925 PyObject * obj2 = 0 ;
7926 PyObject * obj3 = 0 ;
7927 PyObject * obj4 = 0 ;
7928 char * kwnames[] = {
7929 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7930 };
7931
7932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7934 if (!SWIG_IsOK(res1)) {
7935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7936 }
7937 arg1 = reinterpret_cast< wxRect * >(argp1);
7938 if (obj1) {
7939 ecode2 = SWIG_AsVal_int(obj1, &val2);
7940 if (!SWIG_IsOK(ecode2)) {
7941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7942 }
7943 arg2 = static_cast< int >(val2);
7944 }
7945 if (obj2) {
7946 ecode3 = SWIG_AsVal_int(obj2, &val3);
7947 if (!SWIG_IsOK(ecode3)) {
7948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7949 }
7950 arg3 = static_cast< int >(val3);
7951 }
7952 if (obj3) {
7953 ecode4 = SWIG_AsVal_int(obj3, &val4);
7954 if (!SWIG_IsOK(ecode4)) {
7955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7956 }
7957 arg4 = static_cast< int >(val4);
7958 }
7959 if (obj4) {
7960 ecode5 = SWIG_AsVal_int(obj4, &val5);
7961 if (!SWIG_IsOK(ecode5)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7963 }
7964 arg5 = static_cast< int >(val5);
7965 }
7966 {
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7969 wxPyEndAllowThreads(__tstate);
7970 if (PyErr_Occurred()) SWIG_fail;
7971 }
7972 resultobj = SWIG_Py_Void();
7973 return resultobj;
7974 fail:
7975 return NULL;
7976 }
7977
7978
7979 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7980 PyObject *resultobj = 0;
7981 wxRect *arg1 = (wxRect *) 0 ;
7982 PyObject *result = 0 ;
7983 void *argp1 = 0 ;
7984 int res1 = 0 ;
7985 PyObject *swig_obj[1] ;
7986
7987 if (!args) SWIG_fail;
7988 swig_obj[0] = args;
7989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7992 }
7993 arg1 = reinterpret_cast< wxRect * >(argp1);
7994 {
7995 PyThreadState* __tstate = wxPyBeginAllowThreads();
7996 result = (PyObject *)wxRect_Get(arg1);
7997 wxPyEndAllowThreads(__tstate);
7998 if (PyErr_Occurred()) SWIG_fail;
7999 }
8000 resultobj = result;
8001 return resultobj;
8002 fail:
8003 return NULL;
8004 }
8005
8006
8007 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8008 PyObject *obj;
8009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8010 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8011 return SWIG_Py_Void();
8012 }
8013
8014 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8015 return SWIG_Python_InitShadowInstance(args);
8016 }
8017
8018 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8019 PyObject *resultobj = 0;
8020 wxRect *arg1 = (wxRect *) 0 ;
8021 wxRect *arg2 = (wxRect *) 0 ;
8022 PyObject *result = 0 ;
8023 void *argp1 = 0 ;
8024 int res1 = 0 ;
8025 void *argp2 = 0 ;
8026 int res2 = 0 ;
8027 PyObject * obj0 = 0 ;
8028 PyObject * obj1 = 0 ;
8029 char * kwnames[] = {
8030 (char *) "r1",(char *) "r2", NULL
8031 };
8032
8033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8035 if (!SWIG_IsOK(res1)) {
8036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8037 }
8038 arg1 = reinterpret_cast< wxRect * >(argp1);
8039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8040 if (!SWIG_IsOK(res2)) {
8041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8042 }
8043 arg2 = reinterpret_cast< wxRect * >(argp2);
8044 {
8045 if (!wxPyCheckForApp()) SWIG_fail;
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 result = (PyObject *)wxIntersectRect(arg1,arg2);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = result;
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8059 PyObject *resultobj = 0;
8060 double arg1 = (double) 0.0 ;
8061 double arg2 = (double) 0.0 ;
8062 wxPoint2D *result = 0 ;
8063 double val1 ;
8064 int ecode1 = 0 ;
8065 double val2 ;
8066 int ecode2 = 0 ;
8067 PyObject * obj0 = 0 ;
8068 PyObject * obj1 = 0 ;
8069 char * kwnames[] = {
8070 (char *) "x",(char *) "y", NULL
8071 };
8072
8073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8074 if (obj0) {
8075 ecode1 = SWIG_AsVal_double(obj0, &val1);
8076 if (!SWIG_IsOK(ecode1)) {
8077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8078 }
8079 arg1 = static_cast< double >(val1);
8080 }
8081 if (obj1) {
8082 ecode2 = SWIG_AsVal_double(obj1, &val2);
8083 if (!SWIG_IsOK(ecode2)) {
8084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8085 }
8086 arg2 = static_cast< double >(val2);
8087 }
8088 {
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8102 PyObject *resultobj = 0;
8103 wxPoint2D *arg1 = 0 ;
8104 wxPoint2D *result = 0 ;
8105 wxPoint2D temp1 ;
8106 PyObject * obj0 = 0 ;
8107 char * kwnames[] = {
8108 (char *) "pt", NULL
8109 };
8110
8111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8112 {
8113 arg1 = &temp1;
8114 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8115 }
8116 {
8117 PyThreadState* __tstate = wxPyBeginAllowThreads();
8118 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8119 wxPyEndAllowThreads(__tstate);
8120 if (PyErr_Occurred()) SWIG_fail;
8121 }
8122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8123 return resultobj;
8124 fail:
8125 return NULL;
8126 }
8127
8128
8129 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8130 PyObject *resultobj = 0;
8131 wxPoint *arg1 = 0 ;
8132 wxPoint2D *result = 0 ;
8133 wxPoint temp1 ;
8134 PyObject * obj0 = 0 ;
8135 char * kwnames[] = {
8136 (char *) "pt", NULL
8137 };
8138
8139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8140 {
8141 arg1 = &temp1;
8142 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8143 }
8144 {
8145 PyThreadState* __tstate = wxPyBeginAllowThreads();
8146 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8151 return resultobj;
8152 fail:
8153 return NULL;
8154 }
8155
8156
8157 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8158 PyObject *resultobj = 0;
8159 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8160 int *arg2 = (int *) 0 ;
8161 int *arg3 = (int *) 0 ;
8162 void *argp1 = 0 ;
8163 int res1 = 0 ;
8164 int temp2 ;
8165 int res2 = SWIG_TMPOBJ ;
8166 int temp3 ;
8167 int res3 = SWIG_TMPOBJ ;
8168 PyObject *swig_obj[1] ;
8169
8170 arg2 = &temp2;
8171 arg3 = &temp3;
8172 if (!args) SWIG_fail;
8173 swig_obj[0] = args;
8174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8175 if (!SWIG_IsOK(res1)) {
8176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8177 }
8178 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8179 {
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8182 wxPyEndAllowThreads(__tstate);
8183 if (PyErr_Occurred()) SWIG_fail;
8184 }
8185 resultobj = SWIG_Py_Void();
8186 if (SWIG_IsTmpObj(res2)) {
8187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8188 } else {
8189 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8191 }
8192 if (SWIG_IsTmpObj(res3)) {
8193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8194 } else {
8195 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8197 }
8198 return resultobj;
8199 fail:
8200 return NULL;
8201 }
8202
8203
8204 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8205 PyObject *resultobj = 0;
8206 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8207 int *arg2 = (int *) 0 ;
8208 int *arg3 = (int *) 0 ;
8209 void *argp1 = 0 ;
8210 int res1 = 0 ;
8211 int temp2 ;
8212 int res2 = SWIG_TMPOBJ ;
8213 int temp3 ;
8214 int res3 = SWIG_TMPOBJ ;
8215 PyObject *swig_obj[1] ;
8216
8217 arg2 = &temp2;
8218 arg3 = &temp3;
8219 if (!args) SWIG_fail;
8220 swig_obj[0] = args;
8221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8222 if (!SWIG_IsOK(res1)) {
8223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8224 }
8225 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_Py_Void();
8233 if (SWIG_IsTmpObj(res2)) {
8234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8235 } else {
8236 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8238 }
8239 if (SWIG_IsTmpObj(res3)) {
8240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8241 } else {
8242 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8244 }
8245 return resultobj;
8246 fail:
8247 return NULL;
8248 }
8249
8250
8251 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8252 PyObject *resultobj = 0;
8253 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8254 double result;
8255 void *argp1 = 0 ;
8256 int res1 = 0 ;
8257 PyObject *swig_obj[1] ;
8258
8259 if (!args) SWIG_fail;
8260 swig_obj[0] = args;
8261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8262 if (!SWIG_IsOK(res1)) {
8263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8264 }
8265 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8269 wxPyEndAllowThreads(__tstate);
8270 if (PyErr_Occurred()) SWIG_fail;
8271 }
8272 resultobj = SWIG_From_double(static_cast< double >(result));
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8280 PyObject *resultobj = 0;
8281 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8282 double result;
8283 void *argp1 = 0 ;
8284 int res1 = 0 ;
8285 PyObject *swig_obj[1] ;
8286
8287 if (!args) SWIG_fail;
8288 swig_obj[0] = args;
8289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8290 if (!SWIG_IsOK(res1)) {
8291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8292 }
8293 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8294 {
8295 PyThreadState* __tstate = wxPyBeginAllowThreads();
8296 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8297 wxPyEndAllowThreads(__tstate);
8298 if (PyErr_Occurred()) SWIG_fail;
8299 }
8300 resultobj = SWIG_From_double(static_cast< double >(result));
8301 return resultobj;
8302 fail:
8303 return NULL;
8304 }
8305
8306
8307 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8308 PyObject *resultobj = 0;
8309 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8310 double arg2 ;
8311 void *argp1 = 0 ;
8312 int res1 = 0 ;
8313 double val2 ;
8314 int ecode2 = 0 ;
8315 PyObject * obj0 = 0 ;
8316 PyObject * obj1 = 0 ;
8317 char * kwnames[] = {
8318 (char *) "self",(char *) "length", NULL
8319 };
8320
8321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8323 if (!SWIG_IsOK(res1)) {
8324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8325 }
8326 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8327 ecode2 = SWIG_AsVal_double(obj1, &val2);
8328 if (!SWIG_IsOK(ecode2)) {
8329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8330 }
8331 arg2 = static_cast< double >(val2);
8332 {
8333 PyThreadState* __tstate = wxPyBeginAllowThreads();
8334 (arg1)->SetVectorLength(arg2);
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 resultobj = SWIG_Py_Void();
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj = 0;
8347 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8348 double arg2 ;
8349 void *argp1 = 0 ;
8350 int res1 = 0 ;
8351 double val2 ;
8352 int ecode2 = 0 ;
8353 PyObject * obj0 = 0 ;
8354 PyObject * obj1 = 0 ;
8355 char * kwnames[] = {
8356 (char *) "self",(char *) "degrees", NULL
8357 };
8358
8359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8361 if (!SWIG_IsOK(res1)) {
8362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8363 }
8364 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8365 ecode2 = SWIG_AsVal_double(obj1, &val2);
8366 if (!SWIG_IsOK(ecode2)) {
8367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8368 }
8369 arg2 = static_cast< double >(val2);
8370 {
8371 PyThreadState* __tstate = wxPyBeginAllowThreads();
8372 (arg1)->SetVectorAngle(arg2);
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 resultobj = SWIG_Py_Void();
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8384 PyObject *resultobj = 0;
8385 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8386 wxPoint2D *arg2 = 0 ;
8387 double result;
8388 void *argp1 = 0 ;
8389 int res1 = 0 ;
8390 wxPoint2D temp2 ;
8391 PyObject * obj0 = 0 ;
8392 PyObject * obj1 = 0 ;
8393 char * kwnames[] = {
8394 (char *) "self",(char *) "pt", NULL
8395 };
8396
8397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8399 if (!SWIG_IsOK(res1)) {
8400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8401 }
8402 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8403 {
8404 arg2 = &temp2;
8405 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8406 }
8407 {
8408 PyThreadState* __tstate = wxPyBeginAllowThreads();
8409 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8410 wxPyEndAllowThreads(__tstate);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_From_double(static_cast< double >(result));
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8421 PyObject *resultobj = 0;
8422 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8423 wxPoint2D *arg2 = 0 ;
8424 double result;
8425 void *argp1 = 0 ;
8426 int res1 = 0 ;
8427 wxPoint2D temp2 ;
8428 PyObject * obj0 = 0 ;
8429 PyObject * obj1 = 0 ;
8430 char * kwnames[] = {
8431 (char *) "self",(char *) "pt", NULL
8432 };
8433
8434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8436 if (!SWIG_IsOK(res1)) {
8437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8438 }
8439 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8440 {
8441 arg2 = &temp2;
8442 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8443 }
8444 {
8445 PyThreadState* __tstate = wxPyBeginAllowThreads();
8446 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 resultobj = SWIG_From_double(static_cast< double >(result));
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 wxPoint2D *arg2 = 0 ;
8461 double result;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 wxPoint2D temp2 ;
8465 PyObject * obj0 = 0 ;
8466 PyObject * obj1 = 0 ;
8467 char * kwnames[] = {
8468 (char *) "self",(char *) "vec", NULL
8469 };
8470
8471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8475 }
8476 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8477 {
8478 arg2 = &temp2;
8479 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8480 }
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 resultobj = SWIG_From_double(static_cast< double >(result));
8488 return resultobj;
8489 fail:
8490 return NULL;
8491 }
8492
8493
8494 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj = 0;
8496 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8497 wxPoint2D *arg2 = 0 ;
8498 double result;
8499 void *argp1 = 0 ;
8500 int res1 = 0 ;
8501 wxPoint2D temp2 ;
8502 PyObject * obj0 = 0 ;
8503 PyObject * obj1 = 0 ;
8504 char * kwnames[] = {
8505 (char *) "self",(char *) "vec", NULL
8506 };
8507
8508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8510 if (!SWIG_IsOK(res1)) {
8511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8512 }
8513 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8514 {
8515 arg2 = &temp2;
8516 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8517 }
8518 {
8519 PyThreadState* __tstate = wxPyBeginAllowThreads();
8520 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 resultobj = SWIG_From_double(static_cast< double >(result));
8525 return resultobj;
8526 fail:
8527 return NULL;
8528 }
8529
8530
8531 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8532 PyObject *resultobj = 0;
8533 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8534 wxPoint2D result;
8535 void *argp1 = 0 ;
8536 int res1 = 0 ;
8537 PyObject *swig_obj[1] ;
8538
8539 if (!args) SWIG_fail;
8540 swig_obj[0] = args;
8541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8542 if (!SWIG_IsOK(res1)) {
8543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8544 }
8545 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8546 {
8547 PyThreadState* __tstate = wxPyBeginAllowThreads();
8548 result = (arg1)->operator -();
8549 wxPyEndAllowThreads(__tstate);
8550 if (PyErr_Occurred()) SWIG_fail;
8551 }
8552 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8553 return resultobj;
8554 fail:
8555 return NULL;
8556 }
8557
8558
8559 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8560 PyObject *resultobj = 0;
8561 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8562 wxPoint2D *arg2 = 0 ;
8563 wxPoint2D *result = 0 ;
8564 void *argp1 = 0 ;
8565 int res1 = 0 ;
8566 wxPoint2D temp2 ;
8567 PyObject * obj0 = 0 ;
8568 PyObject * obj1 = 0 ;
8569 char * kwnames[] = {
8570 (char *) "self",(char *) "pt", NULL
8571 };
8572
8573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8575 if (!SWIG_IsOK(res1)) {
8576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8577 }
8578 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8579 {
8580 arg2 = &temp2;
8581 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8582 }
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 {
8586 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8587 result = (wxPoint2D *) &_result_ref;
8588 }
8589 wxPyEndAllowThreads(__tstate);
8590 if (PyErr_Occurred()) SWIG_fail;
8591 }
8592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj = 0;
8601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8602 wxPoint2D *arg2 = 0 ;
8603 wxPoint2D *result = 0 ;
8604 void *argp1 = 0 ;
8605 int res1 = 0 ;
8606 wxPoint2D temp2 ;
8607 PyObject * obj0 = 0 ;
8608 PyObject * obj1 = 0 ;
8609 char * kwnames[] = {
8610 (char *) "self",(char *) "pt", NULL
8611 };
8612
8613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8615 if (!SWIG_IsOK(res1)) {
8616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8617 }
8618 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8619 {
8620 arg2 = &temp2;
8621 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8622 }
8623 {
8624 PyThreadState* __tstate = wxPyBeginAllowThreads();
8625 {
8626 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8627 result = (wxPoint2D *) &_result_ref;
8628 }
8629 wxPyEndAllowThreads(__tstate);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8633 return resultobj;
8634 fail:
8635 return NULL;
8636 }
8637
8638
8639 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8640 PyObject *resultobj = 0;
8641 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8642 wxPoint2D *arg2 = 0 ;
8643 wxPoint2D *result = 0 ;
8644 void *argp1 = 0 ;
8645 int res1 = 0 ;
8646 wxPoint2D temp2 ;
8647 PyObject * obj0 = 0 ;
8648 PyObject * obj1 = 0 ;
8649 char * kwnames[] = {
8650 (char *) "self",(char *) "pt", NULL
8651 };
8652
8653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8655 if (!SWIG_IsOK(res1)) {
8656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8657 }
8658 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8659 {
8660 arg2 = &temp2;
8661 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8662 }
8663 {
8664 PyThreadState* __tstate = wxPyBeginAllowThreads();
8665 {
8666 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8667 result = (wxPoint2D *) &_result_ref;
8668 }
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj = 0;
8681 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8682 wxPoint2D *arg2 = 0 ;
8683 wxPoint2D *result = 0 ;
8684 void *argp1 = 0 ;
8685 int res1 = 0 ;
8686 wxPoint2D temp2 ;
8687 PyObject * obj0 = 0 ;
8688 PyObject * obj1 = 0 ;
8689 char * kwnames[] = {
8690 (char *) "self",(char *) "pt", NULL
8691 };
8692
8693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8697 }
8698 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8699 {
8700 arg2 = &temp2;
8701 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8702 }
8703 {
8704 PyThreadState* __tstate = wxPyBeginAllowThreads();
8705 {
8706 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8707 result = (wxPoint2D *) &_result_ref;
8708 }
8709 wxPyEndAllowThreads(__tstate);
8710 if (PyErr_Occurred()) SWIG_fail;
8711 }
8712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj = 0;
8721 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8722 PyObject *arg2 = (PyObject *) 0 ;
8723 bool result;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 PyObject * obj0 = 0 ;
8727 PyObject * obj1 = 0 ;
8728 char * kwnames[] = {
8729 (char *) "self",(char *) "other", NULL
8730 };
8731
8732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8734 if (!SWIG_IsOK(res1)) {
8735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8736 }
8737 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8738 arg2 = obj1;
8739 {
8740 result = (bool)wxPoint2D___eq__(arg1,arg2);
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 {
8744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8745 }
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj = 0;
8754 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8755 PyObject *arg2 = (PyObject *) 0 ;
8756 bool result;
8757 void *argp1 = 0 ;
8758 int res1 = 0 ;
8759 PyObject * obj0 = 0 ;
8760 PyObject * obj1 = 0 ;
8761 char * kwnames[] = {
8762 (char *) "self",(char *) "other", NULL
8763 };
8764
8765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8769 }
8770 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8771 arg2 = obj1;
8772 {
8773 result = (bool)wxPoint2D___ne__(arg1,arg2);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 {
8777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8778 }
8779 return resultobj;
8780 fail:
8781 return NULL;
8782 }
8783
8784
8785 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8786 PyObject *resultobj = 0;
8787 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8788 double arg2 ;
8789 void *argp1 = 0 ;
8790 int res1 = 0 ;
8791 double val2 ;
8792 int ecode2 = 0 ;
8793 PyObject *swig_obj[2] ;
8794
8795 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8797 if (!SWIG_IsOK(res1)) {
8798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8799 }
8800 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8801 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8802 if (!SWIG_IsOK(ecode2)) {
8803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8804 }
8805 arg2 = static_cast< double >(val2);
8806 if (arg1) (arg1)->m_x = arg2;
8807
8808 resultobj = SWIG_Py_Void();
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8816 PyObject *resultobj = 0;
8817 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8818 double result;
8819 void *argp1 = 0 ;
8820 int res1 = 0 ;
8821 PyObject *swig_obj[1] ;
8822
8823 if (!args) SWIG_fail;
8824 swig_obj[0] = args;
8825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8826 if (!SWIG_IsOK(res1)) {
8827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8828 }
8829 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8830 result = (double) ((arg1)->m_x);
8831 resultobj = SWIG_From_double(static_cast< double >(result));
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8839 PyObject *resultobj = 0;
8840 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8841 double arg2 ;
8842 void *argp1 = 0 ;
8843 int res1 = 0 ;
8844 double val2 ;
8845 int ecode2 = 0 ;
8846 PyObject *swig_obj[2] ;
8847
8848 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8852 }
8853 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8854 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8855 if (!SWIG_IsOK(ecode2)) {
8856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8857 }
8858 arg2 = static_cast< double >(val2);
8859 if (arg1) (arg1)->m_y = arg2;
8860
8861 resultobj = SWIG_Py_Void();
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8869 PyObject *resultobj = 0;
8870 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8871 double result;
8872 void *argp1 = 0 ;
8873 int res1 = 0 ;
8874 PyObject *swig_obj[1] ;
8875
8876 if (!args) SWIG_fail;
8877 swig_obj[0] = args;
8878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8879 if (!SWIG_IsOK(res1)) {
8880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8881 }
8882 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8883 result = (double) ((arg1)->m_y);
8884 resultobj = SWIG_From_double(static_cast< double >(result));
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = 0;
8893 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8894 double arg2 = (double) 0 ;
8895 double arg3 = (double) 0 ;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 double val2 ;
8899 int ecode2 = 0 ;
8900 double val3 ;
8901 int ecode3 = 0 ;
8902 PyObject * obj0 = 0 ;
8903 PyObject * obj1 = 0 ;
8904 PyObject * obj2 = 0 ;
8905 char * kwnames[] = {
8906 (char *) "self",(char *) "x",(char *) "y", NULL
8907 };
8908
8909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8911 if (!SWIG_IsOK(res1)) {
8912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8913 }
8914 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8915 if (obj1) {
8916 ecode2 = SWIG_AsVal_double(obj1, &val2);
8917 if (!SWIG_IsOK(ecode2)) {
8918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8919 }
8920 arg2 = static_cast< double >(val2);
8921 }
8922 if (obj2) {
8923 ecode3 = SWIG_AsVal_double(obj2, &val3);
8924 if (!SWIG_IsOK(ecode3)) {
8925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8926 }
8927 arg3 = static_cast< double >(val3);
8928 }
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 wxPoint2D_Set(arg1,arg2,arg3);
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 resultobj = SWIG_Py_Void();
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8943 PyObject *resultobj = 0;
8944 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8945 PyObject *result = 0 ;
8946 void *argp1 = 0 ;
8947 int res1 = 0 ;
8948 PyObject *swig_obj[1] ;
8949
8950 if (!args) SWIG_fail;
8951 swig_obj[0] = args;
8952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8953 if (!SWIG_IsOK(res1)) {
8954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8955 }
8956 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8957 {
8958 PyThreadState* __tstate = wxPyBeginAllowThreads();
8959 result = (PyObject *)wxPoint2D_Get(arg1);
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 resultobj = result;
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8971 PyObject *obj;
8972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8973 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8974 return SWIG_Py_Void();
8975 }
8976
8977 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8978 return SWIG_Python_InitShadowInstance(args);
8979 }
8980
8981 SWIGINTERN int DefaultPosition_set(PyObject *) {
8982 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8983 return 1;
8984 }
8985
8986
8987 SWIGINTERN PyObject *DefaultPosition_get(void) {
8988 PyObject *pyobj = 0;
8989
8990 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8991 return pyobj;
8992 }
8993
8994
8995 SWIGINTERN int DefaultSize_set(PyObject *) {
8996 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8997 return 1;
8998 }
8999
9000
9001 SWIGINTERN PyObject *DefaultSize_get(void) {
9002 PyObject *pyobj = 0;
9003
9004 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9005 return pyobj;
9006 }
9007
9008
9009 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9010 PyObject *resultobj = 0;
9011 PyObject *arg1 = (PyObject *) 0 ;
9012 wxPyInputStream *result = 0 ;
9013 PyObject * obj0 = 0 ;
9014 char * kwnames[] = {
9015 (char *) "p", NULL
9016 };
9017
9018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9019 arg1 = obj0;
9020 {
9021 PyThreadState* __tstate = wxPyBeginAllowThreads();
9022 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9023 wxPyEndAllowThreads(__tstate);
9024 if (PyErr_Occurred()) SWIG_fail;
9025 }
9026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9027 return resultobj;
9028 fail:
9029 return NULL;
9030 }
9031
9032
9033 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 PyObject *resultobj = 0;
9035 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9036 void *argp1 = 0 ;
9037 int res1 = 0 ;
9038 PyObject *swig_obj[1] ;
9039
9040 if (!args) SWIG_fail;
9041 swig_obj[0] = args;
9042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9043 if (!SWIG_IsOK(res1)) {
9044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9045 }
9046 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9047 {
9048 PyThreadState* __tstate = wxPyBeginAllowThreads();
9049 delete arg1;
9050
9051 wxPyEndAllowThreads(__tstate);
9052 if (PyErr_Occurred()) SWIG_fail;
9053 }
9054 resultobj = SWIG_Py_Void();
9055 return resultobj;
9056 fail:
9057 return NULL;
9058 }
9059
9060
9061 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9062 PyObject *resultobj = 0;
9063 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9064 void *argp1 = 0 ;
9065 int res1 = 0 ;
9066 PyObject *swig_obj[1] ;
9067
9068 if (!args) SWIG_fail;
9069 swig_obj[0] = args;
9070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9071 if (!SWIG_IsOK(res1)) {
9072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9073 }
9074 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 (arg1)->close();
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 resultobj = SWIG_Py_Void();
9082 return resultobj;
9083 fail:
9084 return NULL;
9085 }
9086
9087
9088 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9089 PyObject *resultobj = 0;
9090 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9091 void *argp1 = 0 ;
9092 int res1 = 0 ;
9093 PyObject *swig_obj[1] ;
9094
9095 if (!args) SWIG_fail;
9096 swig_obj[0] = args;
9097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9098 if (!SWIG_IsOK(res1)) {
9099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9100 }
9101 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 (arg1)->flush();
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 resultobj = SWIG_Py_Void();
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9116 PyObject *resultobj = 0;
9117 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9118 bool result;
9119 void *argp1 = 0 ;
9120 int res1 = 0 ;
9121 PyObject *swig_obj[1] ;
9122
9123 if (!args) SWIG_fail;
9124 swig_obj[0] = args;
9125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9126 if (!SWIG_IsOK(res1)) {
9127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9128 }
9129 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 result = (bool)(arg1)->eof();
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 {
9137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9138 }
9139 return resultobj;
9140 fail:
9141 return NULL;
9142 }
9143
9144
9145 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9146 PyObject *resultobj = 0;
9147 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9148 int arg2 = (int) -1 ;
9149 PyObject *result = 0 ;
9150 void *argp1 = 0 ;
9151 int res1 = 0 ;
9152 int val2 ;
9153 int ecode2 = 0 ;
9154 PyObject * obj0 = 0 ;
9155 PyObject * obj1 = 0 ;
9156 char * kwnames[] = {
9157 (char *) "self",(char *) "size", NULL
9158 };
9159
9160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9162 if (!SWIG_IsOK(res1)) {
9163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9164 }
9165 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9166 if (obj1) {
9167 ecode2 = SWIG_AsVal_int(obj1, &val2);
9168 if (!SWIG_IsOK(ecode2)) {
9169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9170 }
9171 arg2 = static_cast< int >(val2);
9172 }
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 result = (PyObject *)(arg1)->read(arg2);
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 resultobj = result;
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9187 PyObject *resultobj = 0;
9188 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9189 int arg2 = (int) -1 ;
9190 PyObject *result = 0 ;
9191 void *argp1 = 0 ;
9192 int res1 = 0 ;
9193 int val2 ;
9194 int ecode2 = 0 ;
9195 PyObject * obj0 = 0 ;
9196 PyObject * obj1 = 0 ;
9197 char * kwnames[] = {
9198 (char *) "self",(char *) "size", NULL
9199 };
9200
9201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9203 if (!SWIG_IsOK(res1)) {
9204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9205 }
9206 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9207 if (obj1) {
9208 ecode2 = SWIG_AsVal_int(obj1, &val2);
9209 if (!SWIG_IsOK(ecode2)) {
9210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9211 }
9212 arg2 = static_cast< int >(val2);
9213 }
9214 {
9215 PyThreadState* __tstate = wxPyBeginAllowThreads();
9216 result = (PyObject *)(arg1)->readline(arg2);
9217 wxPyEndAllowThreads(__tstate);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 resultobj = result;
9221 return resultobj;
9222 fail:
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9228 PyObject *resultobj = 0;
9229 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9230 int arg2 = (int) -1 ;
9231 PyObject *result = 0 ;
9232 void *argp1 = 0 ;
9233 int res1 = 0 ;
9234 int val2 ;
9235 int ecode2 = 0 ;
9236 PyObject * obj0 = 0 ;
9237 PyObject * obj1 = 0 ;
9238 char * kwnames[] = {
9239 (char *) "self",(char *) "sizehint", NULL
9240 };
9241
9242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9246 }
9247 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9248 if (obj1) {
9249 ecode2 = SWIG_AsVal_int(obj1, &val2);
9250 if (!SWIG_IsOK(ecode2)) {
9251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9252 }
9253 arg2 = static_cast< int >(val2);
9254 }
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (PyObject *)(arg1)->readlines(arg2);
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 resultobj = result;
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9269 PyObject *resultobj = 0;
9270 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9271 int arg2 ;
9272 int arg3 = (int) 0 ;
9273 void *argp1 = 0 ;
9274 int res1 = 0 ;
9275 int val2 ;
9276 int ecode2 = 0 ;
9277 int val3 ;
9278 int ecode3 = 0 ;
9279 PyObject * obj0 = 0 ;
9280 PyObject * obj1 = 0 ;
9281 PyObject * obj2 = 0 ;
9282 char * kwnames[] = {
9283 (char *) "self",(char *) "offset",(char *) "whence", NULL
9284 };
9285
9286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9288 if (!SWIG_IsOK(res1)) {
9289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9290 }
9291 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9292 ecode2 = SWIG_AsVal_int(obj1, &val2);
9293 if (!SWIG_IsOK(ecode2)) {
9294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9295 }
9296 arg2 = static_cast< int >(val2);
9297 if (obj2) {
9298 ecode3 = SWIG_AsVal_int(obj2, &val3);
9299 if (!SWIG_IsOK(ecode3)) {
9300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9301 }
9302 arg3 = static_cast< int >(val3);
9303 }
9304 {
9305 PyThreadState* __tstate = wxPyBeginAllowThreads();
9306 (arg1)->seek(arg2,arg3);
9307 wxPyEndAllowThreads(__tstate);
9308 if (PyErr_Occurred()) SWIG_fail;
9309 }
9310 resultobj = SWIG_Py_Void();
9311 return resultobj;
9312 fail:
9313 return NULL;
9314 }
9315
9316
9317 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9318 PyObject *resultobj = 0;
9319 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9320 int result;
9321 void *argp1 = 0 ;
9322 int res1 = 0 ;
9323 PyObject *swig_obj[1] ;
9324
9325 if (!args) SWIG_fail;
9326 swig_obj[0] = args;
9327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9328 if (!SWIG_IsOK(res1)) {
9329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9330 }
9331 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9332 {
9333 PyThreadState* __tstate = wxPyBeginAllowThreads();
9334 result = (int)(arg1)->tell();
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 resultobj = SWIG_From_int(static_cast< int >(result));
9339 return resultobj;
9340 fail:
9341 return NULL;
9342 }
9343
9344
9345 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9346 PyObject *resultobj = 0;
9347 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9348 char result;
9349 void *argp1 = 0 ;
9350 int res1 = 0 ;
9351 PyObject *swig_obj[1] ;
9352
9353 if (!args) SWIG_fail;
9354 swig_obj[0] = args;
9355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9356 if (!SWIG_IsOK(res1)) {
9357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9358 }
9359 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9360 {
9361 PyThreadState* __tstate = wxPyBeginAllowThreads();
9362 result = (char)(arg1)->Peek();
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 resultobj = SWIG_From_char(static_cast< char >(result));
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9374 PyObject *resultobj = 0;
9375 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9376 char result;
9377 void *argp1 = 0 ;
9378 int res1 = 0 ;
9379 PyObject *swig_obj[1] ;
9380
9381 if (!args) SWIG_fail;
9382 swig_obj[0] = args;
9383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9384 if (!SWIG_IsOK(res1)) {
9385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9386 }
9387 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (char)(arg1)->GetC();
9391 wxPyEndAllowThreads(__tstate);
9392 if (PyErr_Occurred()) SWIG_fail;
9393 }
9394 resultobj = SWIG_From_char(static_cast< char >(result));
9395 return resultobj;
9396 fail:
9397 return NULL;
9398 }
9399
9400
9401 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9402 PyObject *resultobj = 0;
9403 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9404 size_t result;
9405 void *argp1 = 0 ;
9406 int res1 = 0 ;
9407 PyObject *swig_obj[1] ;
9408
9409 if (!args) SWIG_fail;
9410 swig_obj[0] = args;
9411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9412 if (!SWIG_IsOK(res1)) {
9413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9414 }
9415 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9416 {
9417 PyThreadState* __tstate = wxPyBeginAllowThreads();
9418 result = (size_t)(arg1)->LastRead();
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9430 PyObject *resultobj = 0;
9431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9432 bool result;
9433 void *argp1 = 0 ;
9434 int res1 = 0 ;
9435 PyObject *swig_obj[1] ;
9436
9437 if (!args) SWIG_fail;
9438 swig_obj[0] = args;
9439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9440 if (!SWIG_IsOK(res1)) {
9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9442 }
9443 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9444 {
9445 PyThreadState* __tstate = wxPyBeginAllowThreads();
9446 result = (bool)(arg1)->CanRead();
9447 wxPyEndAllowThreads(__tstate);
9448 if (PyErr_Occurred()) SWIG_fail;
9449 }
9450 {
9451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9452 }
9453 return resultobj;
9454 fail:
9455 return NULL;
9456 }
9457
9458
9459 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9460 PyObject *resultobj = 0;
9461 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9462 bool result;
9463 void *argp1 = 0 ;
9464 int res1 = 0 ;
9465 PyObject *swig_obj[1] ;
9466
9467 if (!args) SWIG_fail;
9468 swig_obj[0] = args;
9469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9470 if (!SWIG_IsOK(res1)) {
9471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9472 }
9473 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (bool)(arg1)->Eof();
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 {
9481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9482 }
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = 0;
9491 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9492 char arg2 ;
9493 bool result;
9494 void *argp1 = 0 ;
9495 int res1 = 0 ;
9496 char val2 ;
9497 int ecode2 = 0 ;
9498 PyObject * obj0 = 0 ;
9499 PyObject * obj1 = 0 ;
9500 char * kwnames[] = {
9501 (char *) "self",(char *) "c", NULL
9502 };
9503
9504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9506 if (!SWIG_IsOK(res1)) {
9507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9508 }
9509 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9510 ecode2 = SWIG_AsVal_char(obj1, &val2);
9511 if (!SWIG_IsOK(ecode2)) {
9512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9513 }
9514 arg2 = static_cast< char >(val2);
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 result = (bool)(arg1)->Ungetch(arg2);
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 {
9522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9523 }
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9531 PyObject *resultobj = 0;
9532 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9533 long arg2 ;
9534 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9535 long result;
9536 void *argp1 = 0 ;
9537 int res1 = 0 ;
9538 long val2 ;
9539 int ecode2 = 0 ;
9540 int val3 ;
9541 int ecode3 = 0 ;
9542 PyObject * obj0 = 0 ;
9543 PyObject * obj1 = 0 ;
9544 PyObject * obj2 = 0 ;
9545 char * kwnames[] = {
9546 (char *) "self",(char *) "pos",(char *) "mode", NULL
9547 };
9548
9549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9551 if (!SWIG_IsOK(res1)) {
9552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9553 }
9554 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9555 ecode2 = SWIG_AsVal_long(obj1, &val2);
9556 if (!SWIG_IsOK(ecode2)) {
9557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9558 }
9559 arg2 = static_cast< long >(val2);
9560 if (obj2) {
9561 ecode3 = SWIG_AsVal_int(obj2, &val3);
9562 if (!SWIG_IsOK(ecode3)) {
9563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9564 }
9565 arg3 = static_cast< wxSeekMode >(val3);
9566 }
9567 {
9568 PyThreadState* __tstate = wxPyBeginAllowThreads();
9569 result = (long)(arg1)->SeekI(arg2,arg3);
9570 wxPyEndAllowThreads(__tstate);
9571 if (PyErr_Occurred()) SWIG_fail;
9572 }
9573 resultobj = SWIG_From_long(static_cast< long >(result));
9574 return resultobj;
9575 fail:
9576 return NULL;
9577 }
9578
9579
9580 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9581 PyObject *resultobj = 0;
9582 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9583 long result;
9584 void *argp1 = 0 ;
9585 int res1 = 0 ;
9586 PyObject *swig_obj[1] ;
9587
9588 if (!args) SWIG_fail;
9589 swig_obj[0] = args;
9590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9591 if (!SWIG_IsOK(res1)) {
9592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9593 }
9594 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 result = (long)(arg1)->TellI();
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_From_long(static_cast< long >(result));
9602 return resultobj;
9603 fail:
9604 return NULL;
9605 }
9606
9607
9608 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9609 PyObject *obj;
9610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9611 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9612 return SWIG_Py_Void();
9613 }
9614
9615 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9616 return SWIG_Python_InitShadowInstance(args);
9617 }
9618
9619 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj = 0;
9621 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9622 PyObject *arg2 = (PyObject *) 0 ;
9623 void *argp1 = 0 ;
9624 int res1 = 0 ;
9625 PyObject * obj0 = 0 ;
9626 PyObject * obj1 = 0 ;
9627 char * kwnames[] = {
9628 (char *) "self",(char *) "obj", NULL
9629 };
9630
9631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9633 if (!SWIG_IsOK(res1)) {
9634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9635 }
9636 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9637 arg2 = obj1;
9638 {
9639 PyThreadState* __tstate = wxPyBeginAllowThreads();
9640 wxOutputStream_write(arg1,arg2);
9641 wxPyEndAllowThreads(__tstate);
9642 if (PyErr_Occurred()) SWIG_fail;
9643 }
9644 resultobj = SWIG_Py_Void();
9645 return resultobj;
9646 fail:
9647 return NULL;
9648 }
9649
9650
9651 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9652 PyObject *resultobj = 0;
9653 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9654 size_t result;
9655 void *argp1 = 0 ;
9656 int res1 = 0 ;
9657 PyObject *swig_obj[1] ;
9658
9659 if (!args) SWIG_fail;
9660 swig_obj[0] = args;
9661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9662 if (!SWIG_IsOK(res1)) {
9663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9664 }
9665 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9666 {
9667 PyThreadState* __tstate = wxPyBeginAllowThreads();
9668 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9669 wxPyEndAllowThreads(__tstate);
9670 if (PyErr_Occurred()) SWIG_fail;
9671 }
9672 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9673 return resultobj;
9674 fail:
9675 return NULL;
9676 }
9677
9678
9679 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9680 PyObject *obj;
9681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9682 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9683 return SWIG_Py_Void();
9684 }
9685
9686 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9687 PyObject *resultobj = 0;
9688 wxInputStream *arg1 = (wxInputStream *) 0 ;
9689 wxString *arg2 = 0 ;
9690 wxString *arg3 = 0 ;
9691 wxString *arg4 = 0 ;
9692 wxDateTime arg5 ;
9693 wxFSFile *result = 0 ;
9694 wxPyInputStream *temp1 ;
9695 bool temp2 = false ;
9696 bool temp3 = false ;
9697 bool temp4 = false ;
9698 void *argp5 ;
9699 int res5 = 0 ;
9700 PyObject * obj0 = 0 ;
9701 PyObject * obj1 = 0 ;
9702 PyObject * obj2 = 0 ;
9703 PyObject * obj3 = 0 ;
9704 PyObject * obj4 = 0 ;
9705 char * kwnames[] = {
9706 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9707 };
9708
9709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9710 {
9711 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9712 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9713 } else {
9714 PyErr_Clear(); // clear the failure of the wxPyConvert above
9715 arg1 = wxPyCBInputStream_create(obj0, true);
9716 if (arg1 == NULL) {
9717 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9718 SWIG_fail;
9719 }
9720 }
9721 }
9722 {
9723 arg2 = wxString_in_helper(obj1);
9724 if (arg2 == NULL) SWIG_fail;
9725 temp2 = true;
9726 }
9727 {
9728 arg3 = wxString_in_helper(obj2);
9729 if (arg3 == NULL) SWIG_fail;
9730 temp3 = true;
9731 }
9732 {
9733 arg4 = wxString_in_helper(obj3);
9734 if (arg4 == NULL) SWIG_fail;
9735 temp4 = true;
9736 }
9737 {
9738 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9739 if (!SWIG_IsOK(res5)) {
9740 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9741 }
9742 if (!argp5) {
9743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9744 } else {
9745 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9746 arg5 = *temp;
9747 if (SWIG_IsNewObj(res5)) delete temp;
9748 }
9749 }
9750 {
9751 PyThreadState* __tstate = wxPyBeginAllowThreads();
9752 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9757 {
9758 if (temp2)
9759 delete arg2;
9760 }
9761 {
9762 if (temp3)
9763 delete arg3;
9764 }
9765 {
9766 if (temp4)
9767 delete arg4;
9768 }
9769 return resultobj;
9770 fail:
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 {
9776 if (temp3)
9777 delete arg3;
9778 }
9779 {
9780 if (temp4)
9781 delete arg4;
9782 }
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9788 PyObject *resultobj = 0;
9789 wxFSFile *arg1 = (wxFSFile *) 0 ;
9790 void *argp1 = 0 ;
9791 int res1 = 0 ;
9792 PyObject *swig_obj[1] ;
9793
9794 if (!args) SWIG_fail;
9795 swig_obj[0] = args;
9796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9797 if (!SWIG_IsOK(res1)) {
9798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9799 }
9800 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 delete arg1;
9804
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 resultobj = SWIG_Py_Void();
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9816 PyObject *resultobj = 0;
9817 wxFSFile *arg1 = (wxFSFile *) 0 ;
9818 wxInputStream *result = 0 ;
9819 void *argp1 = 0 ;
9820 int res1 = 0 ;
9821 PyObject *swig_obj[1] ;
9822
9823 if (!args) SWIG_fail;
9824 swig_obj[0] = args;
9825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9826 if (!SWIG_IsOK(res1)) {
9827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9828 }
9829 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 result = (wxInputStream *)(arg1)->GetStream();
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 {
9837 wxPyInputStream * _ptr = NULL;
9838
9839 if (result) {
9840 _ptr = new wxPyInputStream(result);
9841 }
9842 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9843 }
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9851 PyObject *resultobj = 0;
9852 wxFSFile *arg1 = (wxFSFile *) 0 ;
9853 void *argp1 = 0 ;
9854 int res1 = 0 ;
9855 PyObject *swig_obj[1] ;
9856
9857 if (!args) SWIG_fail;
9858 swig_obj[0] = args;
9859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9860 if (!SWIG_IsOK(res1)) {
9861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9862 }
9863 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9864 {
9865 PyThreadState* __tstate = wxPyBeginAllowThreads();
9866 (arg1)->DetachStream();
9867 wxPyEndAllowThreads(__tstate);
9868 if (PyErr_Occurred()) SWIG_fail;
9869 }
9870 resultobj = SWIG_Py_Void();
9871 return resultobj;
9872 fail:
9873 return NULL;
9874 }
9875
9876
9877 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9878 PyObject *resultobj = 0;
9879 wxFSFile *arg1 = (wxFSFile *) 0 ;
9880 wxString *result = 0 ;
9881 void *argp1 = 0 ;
9882 int res1 = 0 ;
9883 PyObject *swig_obj[1] ;
9884
9885 if (!args) SWIG_fail;
9886 swig_obj[0] = args;
9887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9888 if (!SWIG_IsOK(res1)) {
9889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9890 }
9891 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 {
9895 wxString const &_result_ref = (arg1)->GetMimeType();
9896 result = (wxString *) &_result_ref;
9897 }
9898 wxPyEndAllowThreads(__tstate);
9899 if (PyErr_Occurred()) SWIG_fail;
9900 }
9901 {
9902 #if wxUSE_UNICODE
9903 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9904 #else
9905 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9906 #endif
9907 }
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9915 PyObject *resultobj = 0;
9916 wxFSFile *arg1 = (wxFSFile *) 0 ;
9917 wxString *result = 0 ;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 PyObject *swig_obj[1] ;
9921
9922 if (!args) SWIG_fail;
9923 swig_obj[0] = args;
9924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9925 if (!SWIG_IsOK(res1)) {
9926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9927 }
9928 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 {
9932 wxString const &_result_ref = (arg1)->GetLocation();
9933 result = (wxString *) &_result_ref;
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 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9952 PyObject *resultobj = 0;
9953 wxFSFile *arg1 = (wxFSFile *) 0 ;
9954 wxString *result = 0 ;
9955 void *argp1 = 0 ;
9956 int res1 = 0 ;
9957 PyObject *swig_obj[1] ;
9958
9959 if (!args) SWIG_fail;
9960 swig_obj[0] = args;
9961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9962 if (!SWIG_IsOK(res1)) {
9963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9964 }
9965 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9966 {
9967 PyThreadState* __tstate = wxPyBeginAllowThreads();
9968 {
9969 wxString const &_result_ref = (arg1)->GetAnchor();
9970 result = (wxString *) &_result_ref;
9971 }
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 #if wxUSE_UNICODE
9977 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9978 #else
9979 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9980 #endif
9981 }
9982 return resultobj;
9983 fail:
9984 return NULL;
9985 }
9986
9987
9988 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9989 PyObject *resultobj = 0;
9990 wxFSFile *arg1 = (wxFSFile *) 0 ;
9991 wxDateTime result;
9992 void *argp1 = 0 ;
9993 int res1 = 0 ;
9994 PyObject *swig_obj[1] ;
9995
9996 if (!args) SWIG_fail;
9997 swig_obj[0] = args;
9998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9999 if (!SWIG_IsOK(res1)) {
10000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10001 }
10002 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = (arg1)->GetModificationTime();
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10010 return resultobj;
10011 fail:
10012 return NULL;
10013 }
10014
10015
10016 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10017 PyObject *obj;
10018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10019 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10020 return SWIG_Py_Void();
10021 }
10022
10023 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10024 return SWIG_Python_InitShadowInstance(args);
10025 }
10026
10027 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *resultobj = 0;
10029 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10030 void *argp1 = 0 ;
10031 int res1 = 0 ;
10032 PyObject *swig_obj[1] ;
10033
10034 if (!args) SWIG_fail;
10035 swig_obj[0] = args;
10036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10037 if (!SWIG_IsOK(res1)) {
10038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10039 }
10040 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 delete arg1;
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 resultobj = SWIG_Py_Void();
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10056 PyObject *obj;
10057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10058 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10059 return SWIG_Py_Void();
10060 }
10061
10062 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10063 PyObject *resultobj = 0;
10064 wxPyFileSystemHandler *result = 0 ;
10065
10066 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10067 {
10068 PyThreadState* __tstate = wxPyBeginAllowThreads();
10069 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10070 wxPyEndAllowThreads(__tstate);
10071 if (PyErr_Occurred()) SWIG_fail;
10072 }
10073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10074 return resultobj;
10075 fail:
10076 return NULL;
10077 }
10078
10079
10080 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj = 0;
10082 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10083 PyObject *arg2 = (PyObject *) 0 ;
10084 PyObject *arg3 = (PyObject *) 0 ;
10085 void *argp1 = 0 ;
10086 int res1 = 0 ;
10087 PyObject * obj0 = 0 ;
10088 PyObject * obj1 = 0 ;
10089 PyObject * obj2 = 0 ;
10090 char * kwnames[] = {
10091 (char *) "self",(char *) "self",(char *) "_class", NULL
10092 };
10093
10094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10096 if (!SWIG_IsOK(res1)) {
10097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10098 }
10099 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10100 arg2 = obj1;
10101 arg3 = obj2;
10102 {
10103 PyThreadState* __tstate = wxPyBeginAllowThreads();
10104 (arg1)->_setCallbackInfo(arg2,arg3);
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 resultobj = SWIG_Py_Void();
10109 return resultobj;
10110 fail:
10111 return NULL;
10112 }
10113
10114
10115 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10116 PyObject *resultobj = 0;
10117 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10118 wxString *arg2 = 0 ;
10119 bool result;
10120 void *argp1 = 0 ;
10121 int res1 = 0 ;
10122 bool temp2 = false ;
10123 PyObject * obj0 = 0 ;
10124 PyObject * obj1 = 0 ;
10125 char * kwnames[] = {
10126 (char *) "self",(char *) "location", NULL
10127 };
10128
10129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10131 if (!SWIG_IsOK(res1)) {
10132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10133 }
10134 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10135 {
10136 arg2 = wxString_in_helper(obj1);
10137 if (arg2 == NULL) SWIG_fail;
10138 temp2 = true;
10139 }
10140 {
10141 PyThreadState* __tstate = wxPyBeginAllowThreads();
10142 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10143 wxPyEndAllowThreads(__tstate);
10144 if (PyErr_Occurred()) SWIG_fail;
10145 }
10146 {
10147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10148 }
10149 {
10150 if (temp2)
10151 delete arg2;
10152 }
10153 return resultobj;
10154 fail:
10155 {
10156 if (temp2)
10157 delete arg2;
10158 }
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10166 wxFileSystem *arg2 = 0 ;
10167 wxString *arg3 = 0 ;
10168 wxFSFile *result = 0 ;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 void *argp2 = 0 ;
10172 int res2 = 0 ;
10173 bool temp3 = false ;
10174 PyObject * obj0 = 0 ;
10175 PyObject * obj1 = 0 ;
10176 PyObject * obj2 = 0 ;
10177 char * kwnames[] = {
10178 (char *) "self",(char *) "fs",(char *) "location", NULL
10179 };
10180
10181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10183 if (!SWIG_IsOK(res1)) {
10184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10185 }
10186 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10188 if (!SWIG_IsOK(res2)) {
10189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10190 }
10191 if (!argp2) {
10192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10193 }
10194 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10195 {
10196 arg3 = wxString_in_helper(obj2);
10197 if (arg3 == NULL) SWIG_fail;
10198 temp3 = true;
10199 }
10200 {
10201 PyThreadState* __tstate = wxPyBeginAllowThreads();
10202 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10203 wxPyEndAllowThreads(__tstate);
10204 if (PyErr_Occurred()) SWIG_fail;
10205 }
10206 {
10207 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10208 }
10209 {
10210 if (temp3)
10211 delete arg3;
10212 }
10213 return resultobj;
10214 fail:
10215 {
10216 if (temp3)
10217 delete arg3;
10218 }
10219 return NULL;
10220 }
10221
10222
10223 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10224 PyObject *resultobj = 0;
10225 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10226 wxString *arg2 = 0 ;
10227 int arg3 = (int) 0 ;
10228 wxString result;
10229 void *argp1 = 0 ;
10230 int res1 = 0 ;
10231 bool temp2 = false ;
10232 int val3 ;
10233 int ecode3 = 0 ;
10234 PyObject * obj0 = 0 ;
10235 PyObject * obj1 = 0 ;
10236 PyObject * obj2 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "self",(char *) "spec",(char *) "flags", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10245 }
10246 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10247 {
10248 arg2 = wxString_in_helper(obj1);
10249 if (arg2 == NULL) SWIG_fail;
10250 temp2 = true;
10251 }
10252 if (obj2) {
10253 ecode3 = SWIG_AsVal_int(obj2, &val3);
10254 if (!SWIG_IsOK(ecode3)) {
10255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10256 }
10257 arg3 = static_cast< int >(val3);
10258 }
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 {
10266 #if wxUSE_UNICODE
10267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10268 #else
10269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10270 #endif
10271 }
10272 {
10273 if (temp2)
10274 delete arg2;
10275 }
10276 return resultobj;
10277 fail:
10278 {
10279 if (temp2)
10280 delete arg2;
10281 }
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10287 PyObject *resultobj = 0;
10288 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10289 wxString result;
10290 void *argp1 = 0 ;
10291 int res1 = 0 ;
10292 PyObject *swig_obj[1] ;
10293
10294 if (!args) SWIG_fail;
10295 swig_obj[0] = args;
10296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10297 if (!SWIG_IsOK(res1)) {
10298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10299 }
10300 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10301 {
10302 PyThreadState* __tstate = wxPyBeginAllowThreads();
10303 result = (arg1)->FindNext();
10304 wxPyEndAllowThreads(__tstate);
10305 if (PyErr_Occurred()) SWIG_fail;
10306 }
10307 {
10308 #if wxUSE_UNICODE
10309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10310 #else
10311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10312 #endif
10313 }
10314 return resultobj;
10315 fail:
10316 return NULL;
10317 }
10318
10319
10320 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10321 PyObject *resultobj = 0;
10322 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10323 wxString *arg2 = 0 ;
10324 wxString result;
10325 void *argp1 = 0 ;
10326 int res1 = 0 ;
10327 bool temp2 = false ;
10328 PyObject * obj0 = 0 ;
10329 PyObject * obj1 = 0 ;
10330 char * kwnames[] = {
10331 (char *) "self",(char *) "location", NULL
10332 };
10333
10334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10336 if (!SWIG_IsOK(res1)) {
10337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10338 }
10339 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10340 {
10341 arg2 = wxString_in_helper(obj1);
10342 if (arg2 == NULL) SWIG_fail;
10343 temp2 = true;
10344 }
10345 {
10346 PyThreadState* __tstate = wxPyBeginAllowThreads();
10347 result = (arg1)->GetProtocol((wxString const &)*arg2);
10348 wxPyEndAllowThreads(__tstate);
10349 if (PyErr_Occurred()) SWIG_fail;
10350 }
10351 {
10352 #if wxUSE_UNICODE
10353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10354 #else
10355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10356 #endif
10357 }
10358 {
10359 if (temp2)
10360 delete arg2;
10361 }
10362 return resultobj;
10363 fail:
10364 {
10365 if (temp2)
10366 delete arg2;
10367 }
10368 return NULL;
10369 }
10370
10371
10372 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10373 PyObject *resultobj = 0;
10374 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10375 wxString *arg2 = 0 ;
10376 wxString result;
10377 void *argp1 = 0 ;
10378 int res1 = 0 ;
10379 bool temp2 = false ;
10380 PyObject * obj0 = 0 ;
10381 PyObject * obj1 = 0 ;
10382 char * kwnames[] = {
10383 (char *) "self",(char *) "location", NULL
10384 };
10385
10386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10388 if (!SWIG_IsOK(res1)) {
10389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10390 }
10391 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10392 {
10393 arg2 = wxString_in_helper(obj1);
10394 if (arg2 == NULL) SWIG_fail;
10395 temp2 = true;
10396 }
10397 {
10398 PyThreadState* __tstate = wxPyBeginAllowThreads();
10399 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10400 wxPyEndAllowThreads(__tstate);
10401 if (PyErr_Occurred()) SWIG_fail;
10402 }
10403 {
10404 #if wxUSE_UNICODE
10405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10406 #else
10407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10408 #endif
10409 }
10410 {
10411 if (temp2)
10412 delete arg2;
10413 }
10414 return resultobj;
10415 fail:
10416 {
10417 if (temp2)
10418 delete arg2;
10419 }
10420 return NULL;
10421 }
10422
10423
10424 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10425 PyObject *resultobj = 0;
10426 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10427 wxString *arg2 = 0 ;
10428 wxString result;
10429 void *argp1 = 0 ;
10430 int res1 = 0 ;
10431 bool temp2 = false ;
10432 PyObject * obj0 = 0 ;
10433 PyObject * obj1 = 0 ;
10434 char * kwnames[] = {
10435 (char *) "self",(char *) "location", NULL
10436 };
10437
10438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10440 if (!SWIG_IsOK(res1)) {
10441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10442 }
10443 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10444 {
10445 arg2 = wxString_in_helper(obj1);
10446 if (arg2 == NULL) SWIG_fail;
10447 temp2 = true;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (arg1)->GetAnchor((wxString const &)*arg2);
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 {
10456 #if wxUSE_UNICODE
10457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10458 #else
10459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10460 #endif
10461 }
10462 {
10463 if (temp2)
10464 delete arg2;
10465 }
10466 return resultobj;
10467 fail:
10468 {
10469 if (temp2)
10470 delete arg2;
10471 }
10472 return NULL;
10473 }
10474
10475
10476 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10477 PyObject *resultobj = 0;
10478 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10479 wxString *arg2 = 0 ;
10480 wxString result;
10481 void *argp1 = 0 ;
10482 int res1 = 0 ;
10483 bool temp2 = false ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486 char * kwnames[] = {
10487 (char *) "self",(char *) "location", NULL
10488 };
10489
10490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10492 if (!SWIG_IsOK(res1)) {
10493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10494 }
10495 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10496 {
10497 arg2 = wxString_in_helper(obj1);
10498 if (arg2 == NULL) SWIG_fail;
10499 temp2 = true;
10500 }
10501 {
10502 PyThreadState* __tstate = wxPyBeginAllowThreads();
10503 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10504 wxPyEndAllowThreads(__tstate);
10505 if (PyErr_Occurred()) SWIG_fail;
10506 }
10507 {
10508 #if wxUSE_UNICODE
10509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10510 #else
10511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10512 #endif
10513 }
10514 {
10515 if (temp2)
10516 delete arg2;
10517 }
10518 return resultobj;
10519 fail:
10520 {
10521 if (temp2)
10522 delete arg2;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj = 0;
10530 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10531 wxString *arg2 = 0 ;
10532 wxString result;
10533 void *argp1 = 0 ;
10534 int res1 = 0 ;
10535 bool temp2 = false ;
10536 PyObject * obj0 = 0 ;
10537 PyObject * obj1 = 0 ;
10538 char * kwnames[] = {
10539 (char *) "self",(char *) "location", NULL
10540 };
10541
10542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10544 if (!SWIG_IsOK(res1)) {
10545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10546 }
10547 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10548 {
10549 arg2 = wxString_in_helper(obj1);
10550 if (arg2 == NULL) SWIG_fail;
10551 temp2 = true;
10552 }
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10556 wxPyEndAllowThreads(__tstate);
10557 if (PyErr_Occurred()) SWIG_fail;
10558 }
10559 {
10560 #if wxUSE_UNICODE
10561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10562 #else
10563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10564 #endif
10565 }
10566 {
10567 if (temp2)
10568 delete arg2;
10569 }
10570 return resultobj;
10571 fail:
10572 {
10573 if (temp2)
10574 delete arg2;
10575 }
10576 return NULL;
10577 }
10578
10579
10580 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10581 PyObject *obj;
10582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10583 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10584 return SWIG_Py_Void();
10585 }
10586
10587 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10588 return SWIG_Python_InitShadowInstance(args);
10589 }
10590
10591 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10592 PyObject *resultobj = 0;
10593 wxFileSystem *result = 0 ;
10594
10595 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10596 {
10597 PyThreadState* __tstate = wxPyBeginAllowThreads();
10598 result = (wxFileSystem *)new wxFileSystem();
10599 wxPyEndAllowThreads(__tstate);
10600 if (PyErr_Occurred()) SWIG_fail;
10601 }
10602 {
10603 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10604 }
10605 return resultobj;
10606 fail:
10607 return NULL;
10608 }
10609
10610
10611 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10612 PyObject *resultobj = 0;
10613 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10614 void *argp1 = 0 ;
10615 int res1 = 0 ;
10616 PyObject *swig_obj[1] ;
10617
10618 if (!args) SWIG_fail;
10619 swig_obj[0] = args;
10620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10621 if (!SWIG_IsOK(res1)) {
10622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10623 }
10624 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 delete arg1;
10628
10629 wxPyEndAllowThreads(__tstate);
10630 if (PyErr_Occurred()) SWIG_fail;
10631 }
10632 resultobj = SWIG_Py_Void();
10633 return resultobj;
10634 fail:
10635 return NULL;
10636 }
10637
10638
10639 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj = 0;
10641 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10642 wxString *arg2 = 0 ;
10643 bool arg3 = (bool) false ;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 bool temp2 = false ;
10647 bool val3 ;
10648 int ecode3 = 0 ;
10649 PyObject * obj0 = 0 ;
10650 PyObject * obj1 = 0 ;
10651 PyObject * obj2 = 0 ;
10652 char * kwnames[] = {
10653 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10654 };
10655
10656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10658 if (!SWIG_IsOK(res1)) {
10659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10660 }
10661 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10662 {
10663 arg2 = wxString_in_helper(obj1);
10664 if (arg2 == NULL) SWIG_fail;
10665 temp2 = true;
10666 }
10667 if (obj2) {
10668 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10669 if (!SWIG_IsOK(ecode3)) {
10670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10671 }
10672 arg3 = static_cast< bool >(val3);
10673 }
10674 {
10675 PyThreadState* __tstate = wxPyBeginAllowThreads();
10676 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10677 wxPyEndAllowThreads(__tstate);
10678 if (PyErr_Occurred()) SWIG_fail;
10679 }
10680 resultobj = SWIG_Py_Void();
10681 {
10682 if (temp2)
10683 delete arg2;
10684 }
10685 return resultobj;
10686 fail:
10687 {
10688 if (temp2)
10689 delete arg2;
10690 }
10691 return NULL;
10692 }
10693
10694
10695 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10696 PyObject *resultobj = 0;
10697 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10698 wxString result;
10699 void *argp1 = 0 ;
10700 int res1 = 0 ;
10701 PyObject *swig_obj[1] ;
10702
10703 if (!args) SWIG_fail;
10704 swig_obj[0] = args;
10705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10706 if (!SWIG_IsOK(res1)) {
10707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10708 }
10709 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 result = (arg1)->GetPath();
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 {
10717 #if wxUSE_UNICODE
10718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10719 #else
10720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10721 #endif
10722 }
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj = 0;
10731 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10732 wxString *arg2 = 0 ;
10733 wxFSFile *result = 0 ;
10734 void *argp1 = 0 ;
10735 int res1 = 0 ;
10736 bool temp2 = false ;
10737 PyObject * obj0 = 0 ;
10738 PyObject * obj1 = 0 ;
10739 char * kwnames[] = {
10740 (char *) "self",(char *) "location", NULL
10741 };
10742
10743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10745 if (!SWIG_IsOK(res1)) {
10746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10747 }
10748 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10749 {
10750 arg2 = wxString_in_helper(obj1);
10751 if (arg2 == NULL) SWIG_fail;
10752 temp2 = true;
10753 }
10754 {
10755 PyThreadState* __tstate = wxPyBeginAllowThreads();
10756 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 {
10761 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10762 }
10763 {
10764 if (temp2)
10765 delete arg2;
10766 }
10767 return resultobj;
10768 fail:
10769 {
10770 if (temp2)
10771 delete arg2;
10772 }
10773 return NULL;
10774 }
10775
10776
10777 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10778 PyObject *resultobj = 0;
10779 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10780 wxString *arg2 = 0 ;
10781 int arg3 = (int) 0 ;
10782 wxString result;
10783 void *argp1 = 0 ;
10784 int res1 = 0 ;
10785 bool temp2 = false ;
10786 int val3 ;
10787 int ecode3 = 0 ;
10788 PyObject * obj0 = 0 ;
10789 PyObject * obj1 = 0 ;
10790 PyObject * obj2 = 0 ;
10791 char * kwnames[] = {
10792 (char *) "self",(char *) "spec",(char *) "flags", NULL
10793 };
10794
10795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10797 if (!SWIG_IsOK(res1)) {
10798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10799 }
10800 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10801 {
10802 arg2 = wxString_in_helper(obj1);
10803 if (arg2 == NULL) SWIG_fail;
10804 temp2 = true;
10805 }
10806 if (obj2) {
10807 ecode3 = SWIG_AsVal_int(obj2, &val3);
10808 if (!SWIG_IsOK(ecode3)) {
10809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10810 }
10811 arg3 = static_cast< int >(val3);
10812 }
10813 {
10814 PyThreadState* __tstate = wxPyBeginAllowThreads();
10815 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 {
10820 #if wxUSE_UNICODE
10821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10822 #else
10823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10824 #endif
10825 }
10826 {
10827 if (temp2)
10828 delete arg2;
10829 }
10830 return resultobj;
10831 fail:
10832 {
10833 if (temp2)
10834 delete arg2;
10835 }
10836 return NULL;
10837 }
10838
10839
10840 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10841 PyObject *resultobj = 0;
10842 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10843 wxString result;
10844 void *argp1 = 0 ;
10845 int res1 = 0 ;
10846 PyObject *swig_obj[1] ;
10847
10848 if (!args) SWIG_fail;
10849 swig_obj[0] = args;
10850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10851 if (!SWIG_IsOK(res1)) {
10852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10853 }
10854 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 result = (arg1)->FindNext();
10858 wxPyEndAllowThreads(__tstate);
10859 if (PyErr_Occurred()) SWIG_fail;
10860 }
10861 {
10862 #if wxUSE_UNICODE
10863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10864 #else
10865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10866 #endif
10867 }
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = 0;
10876 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10877 int res1 = 0 ;
10878 PyObject * obj0 = 0 ;
10879 char * kwnames[] = {
10880 (char *) "handler", NULL
10881 };
10882
10883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10884 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10885 if (!SWIG_IsOK(res1)) {
10886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10887 }
10888 {
10889 PyThreadState* __tstate = wxPyBeginAllowThreads();
10890 wxFileSystem::AddHandler(arg1);
10891 wxPyEndAllowThreads(__tstate);
10892 if (PyErr_Occurred()) SWIG_fail;
10893 }
10894 resultobj = SWIG_Py_Void();
10895 return resultobj;
10896 fail:
10897 return NULL;
10898 }
10899
10900
10901 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10902 PyObject *resultobj = 0;
10903 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10904 wxFileSystemHandler *result = 0 ;
10905 void *argp1 = 0 ;
10906 int res1 = 0 ;
10907 PyObject * obj0 = 0 ;
10908 char * kwnames[] = {
10909 (char *) "handler", NULL
10910 };
10911
10912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
10913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10914 if (!SWIG_IsOK(res1)) {
10915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10916 }
10917 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10918 {
10919 PyThreadState* __tstate = wxPyBeginAllowThreads();
10920 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
10921 wxPyEndAllowThreads(__tstate);
10922 if (PyErr_Occurred()) SWIG_fail;
10923 }
10924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10932 PyObject *resultobj = 0;
10933
10934 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10935 {
10936 PyThreadState* __tstate = wxPyBeginAllowThreads();
10937 wxFileSystem::CleanUpHandlers();
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 resultobj = SWIG_Py_Void();
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxString *arg1 = 0 ;
10951 wxString result;
10952 bool temp1 = false ;
10953 PyObject * obj0 = 0 ;
10954 char * kwnames[] = {
10955 (char *) "filename", NULL
10956 };
10957
10958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10959 {
10960 arg1 = wxString_in_helper(obj0);
10961 if (arg1 == NULL) SWIG_fail;
10962 temp1 = true;
10963 }
10964 {
10965 PyThreadState* __tstate = wxPyBeginAllowThreads();
10966 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 {
10971 #if wxUSE_UNICODE
10972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10973 #else
10974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10975 #endif
10976 }
10977 {
10978 if (temp1)
10979 delete arg1;
10980 }
10981 return resultobj;
10982 fail:
10983 {
10984 if (temp1)
10985 delete arg1;
10986 }
10987 return NULL;
10988 }
10989
10990
10991 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10992 PyObject *resultobj = 0;
10993 wxString *arg1 = 0 ;
10994 wxString result;
10995 bool temp1 = false ;
10996 PyObject * obj0 = 0 ;
10997 char * kwnames[] = {
10998 (char *) "url", NULL
10999 };
11000
11001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11002 {
11003 arg1 = wxString_in_helper(obj0);
11004 if (arg1 == NULL) SWIG_fail;
11005 temp1 = true;
11006 }
11007 {
11008 PyThreadState* __tstate = wxPyBeginAllowThreads();
11009 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11010 wxPyEndAllowThreads(__tstate);
11011 if (PyErr_Occurred()) SWIG_fail;
11012 }
11013 {
11014 #if wxUSE_UNICODE
11015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11016 #else
11017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11018 #endif
11019 }
11020 {
11021 if (temp1)
11022 delete arg1;
11023 }
11024 return resultobj;
11025 fail:
11026 {
11027 if (temp1)
11028 delete arg1;
11029 }
11030 return NULL;
11031 }
11032
11033
11034 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11035 PyObject *obj;
11036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11037 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11038 return SWIG_Py_Void();
11039 }
11040
11041 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11042 return SWIG_Python_InitShadowInstance(args);
11043 }
11044
11045 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11046 PyObject *resultobj = 0;
11047 wxInternetFSHandler *result = 0 ;
11048
11049 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11050 {
11051 PyThreadState* __tstate = wxPyBeginAllowThreads();
11052 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11064 PyObject *resultobj = 0;
11065 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11066 wxString *arg2 = 0 ;
11067 bool result;
11068 void *argp1 = 0 ;
11069 int res1 = 0 ;
11070 bool temp2 = false ;
11071 PyObject * obj0 = 0 ;
11072 PyObject * obj1 = 0 ;
11073 char * kwnames[] = {
11074 (char *) "self",(char *) "location", NULL
11075 };
11076
11077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11079 if (!SWIG_IsOK(res1)) {
11080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11081 }
11082 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11083 {
11084 arg2 = wxString_in_helper(obj1);
11085 if (arg2 == NULL) SWIG_fail;
11086 temp2 = true;
11087 }
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11091 wxPyEndAllowThreads(__tstate);
11092 if (PyErr_Occurred()) SWIG_fail;
11093 }
11094 {
11095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11096 }
11097 {
11098 if (temp2)
11099 delete arg2;
11100 }
11101 return resultobj;
11102 fail:
11103 {
11104 if (temp2)
11105 delete arg2;
11106 }
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11112 PyObject *resultobj = 0;
11113 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11114 wxFileSystem *arg2 = 0 ;
11115 wxString *arg3 = 0 ;
11116 wxFSFile *result = 0 ;
11117 void *argp1 = 0 ;
11118 int res1 = 0 ;
11119 void *argp2 = 0 ;
11120 int res2 = 0 ;
11121 bool temp3 = false ;
11122 PyObject * obj0 = 0 ;
11123 PyObject * obj1 = 0 ;
11124 PyObject * obj2 = 0 ;
11125 char * kwnames[] = {
11126 (char *) "self",(char *) "fs",(char *) "location", NULL
11127 };
11128
11129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11131 if (!SWIG_IsOK(res1)) {
11132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11133 }
11134 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11136 if (!SWIG_IsOK(res2)) {
11137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11138 }
11139 if (!argp2) {
11140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11141 }
11142 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11143 {
11144 arg3 = wxString_in_helper(obj2);
11145 if (arg3 == NULL) SWIG_fail;
11146 temp3 = true;
11147 }
11148 {
11149 PyThreadState* __tstate = wxPyBeginAllowThreads();
11150 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11151 wxPyEndAllowThreads(__tstate);
11152 if (PyErr_Occurred()) SWIG_fail;
11153 }
11154 {
11155 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11156 }
11157 {
11158 if (temp3)
11159 delete arg3;
11160 }
11161 return resultobj;
11162 fail:
11163 {
11164 if (temp3)
11165 delete arg3;
11166 }
11167 return NULL;
11168 }
11169
11170
11171 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11172 PyObject *obj;
11173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11174 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11175 return SWIG_Py_Void();
11176 }
11177
11178 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11179 return SWIG_Python_InitShadowInstance(args);
11180 }
11181
11182 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11183 PyObject *resultobj = 0;
11184 wxZipFSHandler *result = 0 ;
11185
11186 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (wxZipFSHandler *)new wxZipFSHandler();
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11201 PyObject *resultobj = 0;
11202 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11203 wxString *arg2 = 0 ;
11204 bool result;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 bool temp2 = false ;
11208 PyObject * obj0 = 0 ;
11209 PyObject * obj1 = 0 ;
11210 char * kwnames[] = {
11211 (char *) "self",(char *) "location", NULL
11212 };
11213
11214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11216 if (!SWIG_IsOK(res1)) {
11217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11218 }
11219 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11220 {
11221 arg2 = wxString_in_helper(obj1);
11222 if (arg2 == NULL) SWIG_fail;
11223 temp2 = true;
11224 }
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11228 wxPyEndAllowThreads(__tstate);
11229 if (PyErr_Occurred()) SWIG_fail;
11230 }
11231 {
11232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11233 }
11234 {
11235 if (temp2)
11236 delete arg2;
11237 }
11238 return resultobj;
11239 fail:
11240 {
11241 if (temp2)
11242 delete arg2;
11243 }
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj = 0;
11250 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11251 wxFileSystem *arg2 = 0 ;
11252 wxString *arg3 = 0 ;
11253 wxFSFile *result = 0 ;
11254 void *argp1 = 0 ;
11255 int res1 = 0 ;
11256 void *argp2 = 0 ;
11257 int res2 = 0 ;
11258 bool temp3 = false ;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 char * kwnames[] = {
11263 (char *) "self",(char *) "fs",(char *) "location", NULL
11264 };
11265
11266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11268 if (!SWIG_IsOK(res1)) {
11269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11270 }
11271 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11273 if (!SWIG_IsOK(res2)) {
11274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11275 }
11276 if (!argp2) {
11277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11278 }
11279 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11280 {
11281 arg3 = wxString_in_helper(obj2);
11282 if (arg3 == NULL) SWIG_fail;
11283 temp3 = true;
11284 }
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 {
11292 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11293 }
11294 {
11295 if (temp3)
11296 delete arg3;
11297 }
11298 return resultobj;
11299 fail:
11300 {
11301 if (temp3)
11302 delete arg3;
11303 }
11304 return NULL;
11305 }
11306
11307
11308 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11309 PyObject *resultobj = 0;
11310 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11311 wxString *arg2 = 0 ;
11312 int arg3 = (int) 0 ;
11313 wxString result;
11314 void *argp1 = 0 ;
11315 int res1 = 0 ;
11316 bool temp2 = false ;
11317 int val3 ;
11318 int ecode3 = 0 ;
11319 PyObject * obj0 = 0 ;
11320 PyObject * obj1 = 0 ;
11321 PyObject * obj2 = 0 ;
11322 char * kwnames[] = {
11323 (char *) "self",(char *) "spec",(char *) "flags", NULL
11324 };
11325
11326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11328 if (!SWIG_IsOK(res1)) {
11329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11330 }
11331 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11332 {
11333 arg2 = wxString_in_helper(obj1);
11334 if (arg2 == NULL) SWIG_fail;
11335 temp2 = true;
11336 }
11337 if (obj2) {
11338 ecode3 = SWIG_AsVal_int(obj2, &val3);
11339 if (!SWIG_IsOK(ecode3)) {
11340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11341 }
11342 arg3 = static_cast< int >(val3);
11343 }
11344 {
11345 PyThreadState* __tstate = wxPyBeginAllowThreads();
11346 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11347 wxPyEndAllowThreads(__tstate);
11348 if (PyErr_Occurred()) SWIG_fail;
11349 }
11350 {
11351 #if wxUSE_UNICODE
11352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11353 #else
11354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11355 #endif
11356 }
11357 {
11358 if (temp2)
11359 delete arg2;
11360 }
11361 return resultobj;
11362 fail:
11363 {
11364 if (temp2)
11365 delete arg2;
11366 }
11367 return NULL;
11368 }
11369
11370
11371 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11372 PyObject *resultobj = 0;
11373 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11374 wxString result;
11375 void *argp1 = 0 ;
11376 int res1 = 0 ;
11377 PyObject *swig_obj[1] ;
11378
11379 if (!args) SWIG_fail;
11380 swig_obj[0] = args;
11381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11382 if (!SWIG_IsOK(res1)) {
11383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11384 }
11385 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11386 {
11387 PyThreadState* __tstate = wxPyBeginAllowThreads();
11388 result = (arg1)->FindNext();
11389 wxPyEndAllowThreads(__tstate);
11390 if (PyErr_Occurred()) SWIG_fail;
11391 }
11392 {
11393 #if wxUSE_UNICODE
11394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11395 #else
11396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11397 #endif
11398 }
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11406 PyObject *obj;
11407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11408 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11409 return SWIG_Py_Void();
11410 }
11411
11412 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11413 return SWIG_Python_InitShadowInstance(args);
11414 }
11415
11416 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj = 0;
11418 wxString *arg1 = 0 ;
11419 wxImage *arg2 = 0 ;
11420 long arg3 ;
11421 bool temp1 = false ;
11422 void *argp2 = 0 ;
11423 int res2 = 0 ;
11424 long val3 ;
11425 int ecode3 = 0 ;
11426 PyObject * obj0 = 0 ;
11427 PyObject * obj1 = 0 ;
11428 PyObject * obj2 = 0 ;
11429 char * kwnames[] = {
11430 (char *) "filename",(char *) "image",(char *) "type", NULL
11431 };
11432
11433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11434 {
11435 arg1 = wxString_in_helper(obj0);
11436 if (arg1 == NULL) SWIG_fail;
11437 temp1 = true;
11438 }
11439 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11440 if (!SWIG_IsOK(res2)) {
11441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11442 }
11443 if (!argp2) {
11444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11445 }
11446 arg2 = reinterpret_cast< wxImage * >(argp2);
11447 ecode3 = SWIG_AsVal_long(obj2, &val3);
11448 if (!SWIG_IsOK(ecode3)) {
11449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11450 }
11451 arg3 = static_cast< long >(val3);
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11455 wxPyEndAllowThreads(__tstate);
11456 if (PyErr_Occurred()) SWIG_fail;
11457 }
11458 resultobj = SWIG_Py_Void();
11459 {
11460 if (temp1)
11461 delete arg1;
11462 }
11463 return resultobj;
11464 fail:
11465 {
11466 if (temp1)
11467 delete arg1;
11468 }
11469 return NULL;
11470 }
11471
11472
11473 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj = 0;
11475 wxString *arg1 = 0 ;
11476 wxBitmap *arg2 = 0 ;
11477 long arg3 ;
11478 bool temp1 = false ;
11479 void *argp2 = 0 ;
11480 int res2 = 0 ;
11481 long val3 ;
11482 int ecode3 = 0 ;
11483 PyObject * obj0 = 0 ;
11484 PyObject * obj1 = 0 ;
11485 PyObject * obj2 = 0 ;
11486 char * kwnames[] = {
11487 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11488 };
11489
11490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11491 {
11492 arg1 = wxString_in_helper(obj0);
11493 if (arg1 == NULL) SWIG_fail;
11494 temp1 = true;
11495 }
11496 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11497 if (!SWIG_IsOK(res2)) {
11498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11499 }
11500 if (!argp2) {
11501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11502 }
11503 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11504 ecode3 = SWIG_AsVal_long(obj2, &val3);
11505 if (!SWIG_IsOK(ecode3)) {
11506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11507 }
11508 arg3 = static_cast< long >(val3);
11509 {
11510 PyThreadState* __tstate = wxPyBeginAllowThreads();
11511 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11512 wxPyEndAllowThreads(__tstate);
11513 if (PyErr_Occurred()) SWIG_fail;
11514 }
11515 resultobj = SWIG_Py_Void();
11516 {
11517 if (temp1)
11518 delete arg1;
11519 }
11520 return resultobj;
11521 fail:
11522 {
11523 if (temp1)
11524 delete arg1;
11525 }
11526 return NULL;
11527 }
11528
11529
11530 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj = 0;
11532 wxString *arg1 = 0 ;
11533 PyObject *arg2 = (PyObject *) 0 ;
11534 bool temp1 = false ;
11535 PyObject * obj0 = 0 ;
11536 PyObject * obj1 = 0 ;
11537 char * kwnames[] = {
11538 (char *) "filename",(char *) "data", NULL
11539 };
11540
11541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11542 {
11543 arg1 = wxString_in_helper(obj0);
11544 if (arg1 == NULL) SWIG_fail;
11545 temp1 = true;
11546 }
11547 arg2 = obj1;
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 resultobj = SWIG_Py_Void();
11555 {
11556 if (temp1)
11557 delete arg1;
11558 }
11559 return resultobj;
11560 fail:
11561 {
11562 if (temp1)
11563 delete arg1;
11564 }
11565 return NULL;
11566 }
11567
11568
11569 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11570 PyObject *resultobj = 0;
11571 wxMemoryFSHandler *result = 0 ;
11572
11573 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11574 {
11575 PyThreadState* __tstate = wxPyBeginAllowThreads();
11576 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11588 PyObject *resultobj = 0;
11589 wxString *arg1 = 0 ;
11590 bool temp1 = false ;
11591 PyObject * obj0 = 0 ;
11592 char * kwnames[] = {
11593 (char *) "filename", NULL
11594 };
11595
11596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11597 {
11598 arg1 = wxString_in_helper(obj0);
11599 if (arg1 == NULL) SWIG_fail;
11600 temp1 = true;
11601 }
11602 {
11603 PyThreadState* __tstate = wxPyBeginAllowThreads();
11604 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 resultobj = SWIG_Py_Void();
11609 {
11610 if (temp1)
11611 delete arg1;
11612 }
11613 return resultobj;
11614 fail:
11615 {
11616 if (temp1)
11617 delete arg1;
11618 }
11619 return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11624 PyObject *resultobj = 0;
11625 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11626 wxString *arg2 = 0 ;
11627 bool result;
11628 void *argp1 = 0 ;
11629 int res1 = 0 ;
11630 bool temp2 = false ;
11631 PyObject * obj0 = 0 ;
11632 PyObject * obj1 = 0 ;
11633 char * kwnames[] = {
11634 (char *) "self",(char *) "location", NULL
11635 };
11636
11637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11639 if (!SWIG_IsOK(res1)) {
11640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11641 }
11642 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11643 {
11644 arg2 = wxString_in_helper(obj1);
11645 if (arg2 == NULL) SWIG_fail;
11646 temp2 = true;
11647 }
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 {
11655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11656 }
11657 {
11658 if (temp2)
11659 delete arg2;
11660 }
11661 return resultobj;
11662 fail:
11663 {
11664 if (temp2)
11665 delete arg2;
11666 }
11667 return NULL;
11668 }
11669
11670
11671 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11672 PyObject *resultobj = 0;
11673 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11674 wxFileSystem *arg2 = 0 ;
11675 wxString *arg3 = 0 ;
11676 wxFSFile *result = 0 ;
11677 void *argp1 = 0 ;
11678 int res1 = 0 ;
11679 void *argp2 = 0 ;
11680 int res2 = 0 ;
11681 bool temp3 = false ;
11682 PyObject * obj0 = 0 ;
11683 PyObject * obj1 = 0 ;
11684 PyObject * obj2 = 0 ;
11685 char * kwnames[] = {
11686 (char *) "self",(char *) "fs",(char *) "location", NULL
11687 };
11688
11689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11691 if (!SWIG_IsOK(res1)) {
11692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11693 }
11694 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11696 if (!SWIG_IsOK(res2)) {
11697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11698 }
11699 if (!argp2) {
11700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11701 }
11702 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11703 {
11704 arg3 = wxString_in_helper(obj2);
11705 if (arg3 == NULL) SWIG_fail;
11706 temp3 = true;
11707 }
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11716 }
11717 {
11718 if (temp3)
11719 delete arg3;
11720 }
11721 return resultobj;
11722 fail:
11723 {
11724 if (temp3)
11725 delete arg3;
11726 }
11727 return NULL;
11728 }
11729
11730
11731 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj = 0;
11733 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11734 wxString *arg2 = 0 ;
11735 int arg3 = (int) 0 ;
11736 wxString result;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 bool temp2 = false ;
11740 int val3 ;
11741 int ecode3 = 0 ;
11742 PyObject * obj0 = 0 ;
11743 PyObject * obj1 = 0 ;
11744 PyObject * obj2 = 0 ;
11745 char * kwnames[] = {
11746 (char *) "self",(char *) "spec",(char *) "flags", NULL
11747 };
11748
11749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11751 if (!SWIG_IsOK(res1)) {
11752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11753 }
11754 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11755 {
11756 arg2 = wxString_in_helper(obj1);
11757 if (arg2 == NULL) SWIG_fail;
11758 temp2 = true;
11759 }
11760 if (obj2) {
11761 ecode3 = SWIG_AsVal_int(obj2, &val3);
11762 if (!SWIG_IsOK(ecode3)) {
11763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11764 }
11765 arg3 = static_cast< int >(val3);
11766 }
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 #if wxUSE_UNICODE
11775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11776 #else
11777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11778 #endif
11779 }
11780 {
11781 if (temp2)
11782 delete arg2;
11783 }
11784 return resultobj;
11785 fail:
11786 {
11787 if (temp2)
11788 delete arg2;
11789 }
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11795 PyObject *resultobj = 0;
11796 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11797 wxString result;
11798 void *argp1 = 0 ;
11799 int res1 = 0 ;
11800 PyObject *swig_obj[1] ;
11801
11802 if (!args) SWIG_fail;
11803 swig_obj[0] = args;
11804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11805 if (!SWIG_IsOK(res1)) {
11806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11807 }
11808 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11809 {
11810 PyThreadState* __tstate = wxPyBeginAllowThreads();
11811 result = (arg1)->FindNext();
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 {
11816 #if wxUSE_UNICODE
11817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11818 #else
11819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11820 #endif
11821 }
11822 return resultobj;
11823 fail:
11824 return NULL;
11825 }
11826
11827
11828 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11829 PyObject *obj;
11830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11831 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11832 return SWIG_Py_Void();
11833 }
11834
11835 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 return SWIG_Python_InitShadowInstance(args);
11837 }
11838
11839 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11840 PyObject *resultobj = 0;
11841 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11842 wxString result;
11843 void *argp1 = 0 ;
11844 int res1 = 0 ;
11845 PyObject *swig_obj[1] ;
11846
11847 if (!args) SWIG_fail;
11848 swig_obj[0] = args;
11849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11850 if (!SWIG_IsOK(res1)) {
11851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11852 }
11853 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11854 {
11855 PyThreadState* __tstate = wxPyBeginAllowThreads();
11856 result = (arg1)->GetName();
11857 wxPyEndAllowThreads(__tstate);
11858 if (PyErr_Occurred()) SWIG_fail;
11859 }
11860 {
11861 #if wxUSE_UNICODE
11862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11863 #else
11864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11865 #endif
11866 }
11867 return resultobj;
11868 fail:
11869 return NULL;
11870 }
11871
11872
11873 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11874 PyObject *resultobj = 0;
11875 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11876 wxString result;
11877 void *argp1 = 0 ;
11878 int res1 = 0 ;
11879 PyObject *swig_obj[1] ;
11880
11881 if (!args) SWIG_fail;
11882 swig_obj[0] = args;
11883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11884 if (!SWIG_IsOK(res1)) {
11885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11886 }
11887 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (arg1)->GetExtension();
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 #if wxUSE_UNICODE
11896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11897 #else
11898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11899 #endif
11900 }
11901 return resultobj;
11902 fail:
11903 return NULL;
11904 }
11905
11906
11907 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11908 PyObject *resultobj = 0;
11909 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11910 long result;
11911 void *argp1 = 0 ;
11912 int res1 = 0 ;
11913 PyObject *swig_obj[1] ;
11914
11915 if (!args) SWIG_fail;
11916 swig_obj[0] = args;
11917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11918 if (!SWIG_IsOK(res1)) {
11919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11920 }
11921 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11922 {
11923 PyThreadState* __tstate = wxPyBeginAllowThreads();
11924 result = (long)(arg1)->GetType();
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 resultobj = SWIG_From_long(static_cast< long >(result));
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11936 PyObject *resultobj = 0;
11937 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11938 wxString result;
11939 void *argp1 = 0 ;
11940 int res1 = 0 ;
11941 PyObject *swig_obj[1] ;
11942
11943 if (!args) SWIG_fail;
11944 swig_obj[0] = args;
11945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11946 if (!SWIG_IsOK(res1)) {
11947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11948 }
11949 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (arg1)->GetMimeType();
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 #if wxUSE_UNICODE
11958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11959 #else
11960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11961 #endif
11962 }
11963 return resultobj;
11964 fail:
11965 return NULL;
11966 }
11967
11968
11969 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11970 PyObject *resultobj = 0;
11971 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11972 wxString *arg2 = 0 ;
11973 bool result;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 bool temp2 = false ;
11977 PyObject * obj0 = 0 ;
11978 PyObject * obj1 = 0 ;
11979 char * kwnames[] = {
11980 (char *) "self",(char *) "name", NULL
11981 };
11982
11983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11985 if (!SWIG_IsOK(res1)) {
11986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11987 }
11988 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11989 {
11990 arg2 = wxString_in_helper(obj1);
11991 if (arg2 == NULL) SWIG_fail;
11992 temp2 = true;
11993 }
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 {
12001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12002 }
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 return resultobj;
12008 fail:
12009 {
12010 if (temp2)
12011 delete arg2;
12012 }
12013 return NULL;
12014 }
12015
12016
12017 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj = 0;
12019 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12020 wxInputStream *arg2 = 0 ;
12021 bool result;
12022 void *argp1 = 0 ;
12023 int res1 = 0 ;
12024 wxPyInputStream *temp2 ;
12025 bool created2 ;
12026 PyObject * obj0 = 0 ;
12027 PyObject * obj1 = 0 ;
12028 char * kwnames[] = {
12029 (char *) "self",(char *) "stream", NULL
12030 };
12031
12032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12034 if (!SWIG_IsOK(res1)) {
12035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12036 }
12037 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12038 {
12039 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12040 arg2 = temp2->m_wxis;
12041 created2 = false;
12042 } else {
12043 PyErr_Clear(); // clear the failure of the wxPyConvert above
12044 arg2 = wxPyCBInputStream_create(obj1, false);
12045 if (arg2 == NULL) {
12046 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12047 SWIG_fail;
12048 }
12049 created2 = true;
12050 }
12051 }
12052 {
12053 PyThreadState* __tstate = wxPyBeginAllowThreads();
12054 result = (bool)(arg1)->CanRead(*arg2);
12055 wxPyEndAllowThreads(__tstate);
12056 if (PyErr_Occurred()) SWIG_fail;
12057 }
12058 {
12059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12060 }
12061 {
12062 if (created2) delete arg2;
12063 }
12064 return resultobj;
12065 fail:
12066 {
12067 if (created2) delete arg2;
12068 }
12069 return NULL;
12070 }
12071
12072
12073 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12074 PyObject *resultobj = 0;
12075 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12076 wxString *arg2 = 0 ;
12077 void *argp1 = 0 ;
12078 int res1 = 0 ;
12079 bool temp2 = false ;
12080 PyObject * obj0 = 0 ;
12081 PyObject * obj1 = 0 ;
12082 char * kwnames[] = {
12083 (char *) "self",(char *) "name", NULL
12084 };
12085
12086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12088 if (!SWIG_IsOK(res1)) {
12089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12090 }
12091 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12092 {
12093 arg2 = wxString_in_helper(obj1);
12094 if (arg2 == NULL) SWIG_fail;
12095 temp2 = true;
12096 }
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 (arg1)->SetName((wxString const &)*arg2);
12100 wxPyEndAllowThreads(__tstate);
12101 if (PyErr_Occurred()) SWIG_fail;
12102 }
12103 resultobj = SWIG_Py_Void();
12104 {
12105 if (temp2)
12106 delete arg2;
12107 }
12108 return resultobj;
12109 fail:
12110 {
12111 if (temp2)
12112 delete arg2;
12113 }
12114 return NULL;
12115 }
12116
12117
12118 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj = 0;
12120 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12121 wxString *arg2 = 0 ;
12122 void *argp1 = 0 ;
12123 int res1 = 0 ;
12124 bool temp2 = false ;
12125 PyObject * obj0 = 0 ;
12126 PyObject * obj1 = 0 ;
12127 char * kwnames[] = {
12128 (char *) "self",(char *) "extension", NULL
12129 };
12130
12131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12133 if (!SWIG_IsOK(res1)) {
12134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12135 }
12136 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12137 {
12138 arg2 = wxString_in_helper(obj1);
12139 if (arg2 == NULL) SWIG_fail;
12140 temp2 = true;
12141 }
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 (arg1)->SetExtension((wxString const &)*arg2);
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 resultobj = SWIG_Py_Void();
12149 {
12150 if (temp2)
12151 delete arg2;
12152 }
12153 return resultobj;
12154 fail:
12155 {
12156 if (temp2)
12157 delete arg2;
12158 }
12159 return NULL;
12160 }
12161
12162
12163 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj = 0;
12165 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12166 long arg2 ;
12167 void *argp1 = 0 ;
12168 int res1 = 0 ;
12169 long val2 ;
12170 int ecode2 = 0 ;
12171 PyObject * obj0 = 0 ;
12172 PyObject * obj1 = 0 ;
12173 char * kwnames[] = {
12174 (char *) "self",(char *) "type", NULL
12175 };
12176
12177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12179 if (!SWIG_IsOK(res1)) {
12180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12181 }
12182 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12183 ecode2 = SWIG_AsVal_long(obj1, &val2);
12184 if (!SWIG_IsOK(ecode2)) {
12185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12186 }
12187 arg2 = static_cast< long >(val2);
12188 {
12189 PyThreadState* __tstate = wxPyBeginAllowThreads();
12190 (arg1)->SetType(arg2);
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 resultobj = SWIG_Py_Void();
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12202 PyObject *resultobj = 0;
12203 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12204 wxString *arg2 = 0 ;
12205 void *argp1 = 0 ;
12206 int res1 = 0 ;
12207 bool temp2 = false ;
12208 PyObject * obj0 = 0 ;
12209 PyObject * obj1 = 0 ;
12210 char * kwnames[] = {
12211 (char *) "self",(char *) "mimetype", NULL
12212 };
12213
12214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12216 if (!SWIG_IsOK(res1)) {
12217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12218 }
12219 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12220 {
12221 arg2 = wxString_in_helper(obj1);
12222 if (arg2 == NULL) SWIG_fail;
12223 temp2 = true;
12224 }
12225 {
12226 PyThreadState* __tstate = wxPyBeginAllowThreads();
12227 (arg1)->SetMimeType((wxString const &)*arg2);
12228 wxPyEndAllowThreads(__tstate);
12229 if (PyErr_Occurred()) SWIG_fail;
12230 }
12231 resultobj = SWIG_Py_Void();
12232 {
12233 if (temp2)
12234 delete arg2;
12235 }
12236 return resultobj;
12237 fail:
12238 {
12239 if (temp2)
12240 delete arg2;
12241 }
12242 return NULL;
12243 }
12244
12245
12246 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12247 PyObject *obj;
12248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12249 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12250 return SWIG_Py_Void();
12251 }
12252
12253 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12254 PyObject *resultobj = 0;
12255 wxPyImageHandler *result = 0 ;
12256
12257 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (wxPyImageHandler *)new wxPyImageHandler();
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj = 0;
12273 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12274 PyObject *arg2 = (PyObject *) 0 ;
12275 void *argp1 = 0 ;
12276 int res1 = 0 ;
12277 PyObject * obj0 = 0 ;
12278 PyObject * obj1 = 0 ;
12279 char * kwnames[] = {
12280 (char *) "self",(char *) "self", NULL
12281 };
12282
12283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12285 if (!SWIG_IsOK(res1)) {
12286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12287 }
12288 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12289 arg2 = obj1;
12290 {
12291 PyThreadState* __tstate = wxPyBeginAllowThreads();
12292 (arg1)->_SetSelf(arg2);
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 resultobj = SWIG_Py_Void();
12297 return resultobj;
12298 fail:
12299 return NULL;
12300 }
12301
12302
12303 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12304 PyObject *obj;
12305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12306 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12307 return SWIG_Py_Void();
12308 }
12309
12310 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12311 return SWIG_Python_InitShadowInstance(args);
12312 }
12313
12314 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12315 PyObject *resultobj = 0;
12316 wxImageHistogram *result = 0 ;
12317
12318 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (wxImageHistogram *)new wxImageHistogram();
12322 wxPyEndAllowThreads(__tstate);
12323 if (PyErr_Occurred()) SWIG_fail;
12324 }
12325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12333 PyObject *resultobj = 0;
12334 byte arg1 ;
12335 byte arg2 ;
12336 byte arg3 ;
12337 unsigned long result;
12338 unsigned char val1 ;
12339 int ecode1 = 0 ;
12340 unsigned char val2 ;
12341 int ecode2 = 0 ;
12342 unsigned char val3 ;
12343 int ecode3 = 0 ;
12344 PyObject * obj0 = 0 ;
12345 PyObject * obj1 = 0 ;
12346 PyObject * obj2 = 0 ;
12347 char * kwnames[] = {
12348 (char *) "r",(char *) "g",(char *) "b", NULL
12349 };
12350
12351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12352 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12353 if (!SWIG_IsOK(ecode1)) {
12354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12355 }
12356 arg1 = static_cast< byte >(val1);
12357 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12358 if (!SWIG_IsOK(ecode2)) {
12359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12360 }
12361 arg2 = static_cast< byte >(val2);
12362 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12363 if (!SWIG_IsOK(ecode3)) {
12364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12365 }
12366 arg3 = static_cast< byte >(val3);
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12370 wxPyEndAllowThreads(__tstate);
12371 if (PyErr_Occurred()) SWIG_fail;
12372 }
12373 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12381 PyObject *resultobj = 0;
12382 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12383 byte *arg2 = (byte *) 0 ;
12384 byte *arg3 = (byte *) 0 ;
12385 byte *arg4 = (byte *) 0 ;
12386 byte arg5 = (byte) 1 ;
12387 byte arg6 = (byte) 0 ;
12388 byte arg7 = (byte) 0 ;
12389 bool result;
12390 void *argp1 = 0 ;
12391 int res1 = 0 ;
12392 byte temp2 ;
12393 int res2 = SWIG_TMPOBJ ;
12394 byte temp3 ;
12395 int res3 = SWIG_TMPOBJ ;
12396 byte temp4 ;
12397 int res4 = SWIG_TMPOBJ ;
12398 unsigned char val5 ;
12399 int ecode5 = 0 ;
12400 unsigned char val6 ;
12401 int ecode6 = 0 ;
12402 unsigned char val7 ;
12403 int ecode7 = 0 ;
12404 PyObject * obj0 = 0 ;
12405 PyObject * obj1 = 0 ;
12406 PyObject * obj2 = 0 ;
12407 PyObject * obj3 = 0 ;
12408 char * kwnames[] = {
12409 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12410 };
12411
12412 arg2 = &temp2;
12413 arg3 = &temp3;
12414 arg4 = &temp4;
12415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12417 if (!SWIG_IsOK(res1)) {
12418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12419 }
12420 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12421 if (obj1) {
12422 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12423 if (!SWIG_IsOK(ecode5)) {
12424 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12425 }
12426 arg5 = static_cast< byte >(val5);
12427 }
12428 if (obj2) {
12429 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12430 if (!SWIG_IsOK(ecode6)) {
12431 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12432 }
12433 arg6 = static_cast< byte >(val6);
12434 }
12435 if (obj3) {
12436 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12437 if (!SWIG_IsOK(ecode7)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12439 }
12440 arg7 = static_cast< byte >(val7);
12441 }
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12445 wxPyEndAllowThreads(__tstate);
12446 if (PyErr_Occurred()) SWIG_fail;
12447 }
12448 {
12449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12450 }
12451 if (SWIG_IsTmpObj(res2)) {
12452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12453 } else {
12454 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12456 }
12457 if (SWIG_IsTmpObj(res3)) {
12458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12459 } else {
12460 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12462 }
12463 if (SWIG_IsTmpObj(res4)) {
12464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12465 } else {
12466 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12468 }
12469 return resultobj;
12470 fail:
12471 return NULL;
12472 }
12473
12474
12475 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12476 PyObject *resultobj = 0;
12477 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12478 unsigned long arg2 ;
12479 unsigned long result;
12480 void *argp1 = 0 ;
12481 int res1 = 0 ;
12482 unsigned long val2 ;
12483 int ecode2 = 0 ;
12484 PyObject * obj0 = 0 ;
12485 PyObject * obj1 = 0 ;
12486 char * kwnames[] = {
12487 (char *) "self",(char *) "key", NULL
12488 };
12489
12490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12492 if (!SWIG_IsOK(res1)) {
12493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12494 }
12495 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12496 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12497 if (!SWIG_IsOK(ecode2)) {
12498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12499 }
12500 arg2 = static_cast< unsigned long >(val2);
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12515 PyObject *resultobj = 0;
12516 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12517 byte arg2 ;
12518 byte arg3 ;
12519 byte arg4 ;
12520 unsigned long result;
12521 void *argp1 = 0 ;
12522 int res1 = 0 ;
12523 unsigned char val2 ;
12524 int ecode2 = 0 ;
12525 unsigned char val3 ;
12526 int ecode3 = 0 ;
12527 unsigned char val4 ;
12528 int ecode4 = 0 ;
12529 PyObject * obj0 = 0 ;
12530 PyObject * obj1 = 0 ;
12531 PyObject * obj2 = 0 ;
12532 PyObject * obj3 = 0 ;
12533 char * kwnames[] = {
12534 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12535 };
12536
12537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12539 if (!SWIG_IsOK(res1)) {
12540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12541 }
12542 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12543 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12544 if (!SWIG_IsOK(ecode2)) {
12545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12546 }
12547 arg2 = static_cast< byte >(val2);
12548 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12549 if (!SWIG_IsOK(ecode3)) {
12550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12551 }
12552 arg3 = static_cast< byte >(val3);
12553 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12554 if (!SWIG_IsOK(ecode4)) {
12555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12556 }
12557 arg4 = static_cast< byte >(val4);
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12572 PyObject *resultobj = 0;
12573 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12574 wxColour *arg2 = 0 ;
12575 unsigned long result;
12576 void *argp1 = 0 ;
12577 int res1 = 0 ;
12578 wxColour temp2 ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 char * kwnames[] = {
12582 (char *) "self",(char *) "colour", NULL
12583 };
12584
12585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12587 if (!SWIG_IsOK(res1)) {
12588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12589 }
12590 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12591 {
12592 arg2 = &temp2;
12593 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12594 }
12595 {
12596 PyThreadState* __tstate = wxPyBeginAllowThreads();
12597 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12598 wxPyEndAllowThreads(__tstate);
12599 if (PyErr_Occurred()) SWIG_fail;
12600 }
12601 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12602 return resultobj;
12603 fail:
12604 return NULL;
12605 }
12606
12607
12608 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12609 PyObject *obj;
12610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12611 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12612 return SWIG_Py_Void();
12613 }
12614
12615 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12616 return SWIG_Python_InitShadowInstance(args);
12617 }
12618
12619 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj = 0;
12621 byte arg1 = (byte) 0 ;
12622 byte arg2 = (byte) 0 ;
12623 byte arg3 = (byte) 0 ;
12624 wxImage_RGBValue *result = 0 ;
12625 unsigned char val1 ;
12626 int ecode1 = 0 ;
12627 unsigned char val2 ;
12628 int ecode2 = 0 ;
12629 unsigned char val3 ;
12630 int ecode3 = 0 ;
12631 PyObject * obj0 = 0 ;
12632 PyObject * obj1 = 0 ;
12633 PyObject * obj2 = 0 ;
12634 char * kwnames[] = {
12635 (char *) "r",(char *) "g",(char *) "b", NULL
12636 };
12637
12638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12639 if (obj0) {
12640 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12641 if (!SWIG_IsOK(ecode1)) {
12642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12643 }
12644 arg1 = static_cast< byte >(val1);
12645 }
12646 if (obj1) {
12647 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12648 if (!SWIG_IsOK(ecode2)) {
12649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12650 }
12651 arg2 = static_cast< byte >(val2);
12652 }
12653 if (obj2) {
12654 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12655 if (!SWIG_IsOK(ecode3)) {
12656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12657 }
12658 arg3 = static_cast< byte >(val3);
12659 }
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12674 PyObject *resultobj = 0;
12675 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12676 byte arg2 ;
12677 void *argp1 = 0 ;
12678 int res1 = 0 ;
12679 unsigned char val2 ;
12680 int ecode2 = 0 ;
12681 PyObject *swig_obj[2] ;
12682
12683 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12685 if (!SWIG_IsOK(res1)) {
12686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12687 }
12688 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12689 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12690 if (!SWIG_IsOK(ecode2)) {
12691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12692 }
12693 arg2 = static_cast< byte >(val2);
12694 if (arg1) (arg1)->red = arg2;
12695
12696 resultobj = SWIG_Py_Void();
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12704 PyObject *resultobj = 0;
12705 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12706 byte result;
12707 void *argp1 = 0 ;
12708 int res1 = 0 ;
12709 PyObject *swig_obj[1] ;
12710
12711 if (!args) SWIG_fail;
12712 swig_obj[0] = args;
12713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12714 if (!SWIG_IsOK(res1)) {
12715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12716 }
12717 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12718 result = (byte) ((arg1)->red);
12719 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12720 return resultobj;
12721 fail:
12722 return NULL;
12723 }
12724
12725
12726 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12727 PyObject *resultobj = 0;
12728 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12729 byte arg2 ;
12730 void *argp1 = 0 ;
12731 int res1 = 0 ;
12732 unsigned char val2 ;
12733 int ecode2 = 0 ;
12734 PyObject *swig_obj[2] ;
12735
12736 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12738 if (!SWIG_IsOK(res1)) {
12739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12740 }
12741 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12742 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12743 if (!SWIG_IsOK(ecode2)) {
12744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12745 }
12746 arg2 = static_cast< byte >(val2);
12747 if (arg1) (arg1)->green = arg2;
12748
12749 resultobj = SWIG_Py_Void();
12750 return resultobj;
12751 fail:
12752 return NULL;
12753 }
12754
12755
12756 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12757 PyObject *resultobj = 0;
12758 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12759 byte result;
12760 void *argp1 = 0 ;
12761 int res1 = 0 ;
12762 PyObject *swig_obj[1] ;
12763
12764 if (!args) SWIG_fail;
12765 swig_obj[0] = args;
12766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12767 if (!SWIG_IsOK(res1)) {
12768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12769 }
12770 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12771 result = (byte) ((arg1)->green);
12772 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12780 PyObject *resultobj = 0;
12781 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12782 byte arg2 ;
12783 void *argp1 = 0 ;
12784 int res1 = 0 ;
12785 unsigned char val2 ;
12786 int ecode2 = 0 ;
12787 PyObject *swig_obj[2] ;
12788
12789 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12791 if (!SWIG_IsOK(res1)) {
12792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12793 }
12794 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12795 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12796 if (!SWIG_IsOK(ecode2)) {
12797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12798 }
12799 arg2 = static_cast< byte >(val2);
12800 if (arg1) (arg1)->blue = arg2;
12801
12802 resultobj = SWIG_Py_Void();
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12810 PyObject *resultobj = 0;
12811 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12812 byte result;
12813 void *argp1 = 0 ;
12814 int res1 = 0 ;
12815 PyObject *swig_obj[1] ;
12816
12817 if (!args) SWIG_fail;
12818 swig_obj[0] = args;
12819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12820 if (!SWIG_IsOK(res1)) {
12821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12822 }
12823 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12824 result = (byte) ((arg1)->blue);
12825 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12833 PyObject *obj;
12834 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12835 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12836 return SWIG_Py_Void();
12837 }
12838
12839 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840 return SWIG_Python_InitShadowInstance(args);
12841 }
12842
12843 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12844 PyObject *resultobj = 0;
12845 double arg1 = (double) 0.0 ;
12846 double arg2 = (double) 0.0 ;
12847 double arg3 = (double) 0.0 ;
12848 wxImage_HSVValue *result = 0 ;
12849 double val1 ;
12850 int ecode1 = 0 ;
12851 double val2 ;
12852 int ecode2 = 0 ;
12853 double val3 ;
12854 int ecode3 = 0 ;
12855 PyObject * obj0 = 0 ;
12856 PyObject * obj1 = 0 ;
12857 PyObject * obj2 = 0 ;
12858 char * kwnames[] = {
12859 (char *) "h",(char *) "s",(char *) "v", NULL
12860 };
12861
12862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12863 if (obj0) {
12864 ecode1 = SWIG_AsVal_double(obj0, &val1);
12865 if (!SWIG_IsOK(ecode1)) {
12866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12867 }
12868 arg1 = static_cast< double >(val1);
12869 }
12870 if (obj1) {
12871 ecode2 = SWIG_AsVal_double(obj1, &val2);
12872 if (!SWIG_IsOK(ecode2)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12874 }
12875 arg2 = static_cast< double >(val2);
12876 }
12877 if (obj2) {
12878 ecode3 = SWIG_AsVal_double(obj2, &val3);
12879 if (!SWIG_IsOK(ecode3)) {
12880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12881 }
12882 arg3 = static_cast< double >(val3);
12883 }
12884 {
12885 PyThreadState* __tstate = wxPyBeginAllowThreads();
12886 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12891 return resultobj;
12892 fail:
12893 return NULL;
12894 }
12895
12896
12897 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12898 PyObject *resultobj = 0;
12899 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12900 double arg2 ;
12901 void *argp1 = 0 ;
12902 int res1 = 0 ;
12903 double val2 ;
12904 int ecode2 = 0 ;
12905 PyObject *swig_obj[2] ;
12906
12907 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12909 if (!SWIG_IsOK(res1)) {
12910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12911 }
12912 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12913 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12914 if (!SWIG_IsOK(ecode2)) {
12915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12916 }
12917 arg2 = static_cast< double >(val2);
12918 if (arg1) (arg1)->hue = arg2;
12919
12920 resultobj = SWIG_Py_Void();
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 PyObject *resultobj = 0;
12929 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12930 double result;
12931 void *argp1 = 0 ;
12932 int res1 = 0 ;
12933 PyObject *swig_obj[1] ;
12934
12935 if (!args) SWIG_fail;
12936 swig_obj[0] = args;
12937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12938 if (!SWIG_IsOK(res1)) {
12939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12940 }
12941 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12942 result = (double) ((arg1)->hue);
12943 resultobj = SWIG_From_double(static_cast< double >(result));
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12951 PyObject *resultobj = 0;
12952 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12953 double arg2 ;
12954 void *argp1 = 0 ;
12955 int res1 = 0 ;
12956 double val2 ;
12957 int ecode2 = 0 ;
12958 PyObject *swig_obj[2] ;
12959
12960 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12962 if (!SWIG_IsOK(res1)) {
12963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12964 }
12965 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12966 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12967 if (!SWIG_IsOK(ecode2)) {
12968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12969 }
12970 arg2 = static_cast< double >(val2);
12971 if (arg1) (arg1)->saturation = arg2;
12972
12973 resultobj = SWIG_Py_Void();
12974 return resultobj;
12975 fail:
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12981 PyObject *resultobj = 0;
12982 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12983 double result;
12984 void *argp1 = 0 ;
12985 int res1 = 0 ;
12986 PyObject *swig_obj[1] ;
12987
12988 if (!args) SWIG_fail;
12989 swig_obj[0] = args;
12990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12991 if (!SWIG_IsOK(res1)) {
12992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12993 }
12994 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12995 result = (double) ((arg1)->saturation);
12996 resultobj = SWIG_From_double(static_cast< double >(result));
12997 return resultobj;
12998 fail:
12999 return NULL;
13000 }
13001
13002
13003 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13004 PyObject *resultobj = 0;
13005 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13006 double arg2 ;
13007 void *argp1 = 0 ;
13008 int res1 = 0 ;
13009 double val2 ;
13010 int ecode2 = 0 ;
13011 PyObject *swig_obj[2] ;
13012
13013 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13015 if (!SWIG_IsOK(res1)) {
13016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13017 }
13018 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13019 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13020 if (!SWIG_IsOK(ecode2)) {
13021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13022 }
13023 arg2 = static_cast< double >(val2);
13024 if (arg1) (arg1)->value = arg2;
13025
13026 resultobj = SWIG_Py_Void();
13027 return resultobj;
13028 fail:
13029 return NULL;
13030 }
13031
13032
13033 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13034 PyObject *resultobj = 0;
13035 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13036 double result;
13037 void *argp1 = 0 ;
13038 int res1 = 0 ;
13039 PyObject *swig_obj[1] ;
13040
13041 if (!args) SWIG_fail;
13042 swig_obj[0] = args;
13043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13044 if (!SWIG_IsOK(res1)) {
13045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13046 }
13047 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13048 result = (double) ((arg1)->value);
13049 resultobj = SWIG_From_double(static_cast< double >(result));
13050 return resultobj;
13051 fail:
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *obj;
13058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13059 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13060 return SWIG_Py_Void();
13061 }
13062
13063 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13064 return SWIG_Python_InitShadowInstance(args);
13065 }
13066
13067 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj = 0;
13069 wxString *arg1 = 0 ;
13070 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13071 int arg3 = (int) -1 ;
13072 wxImage *result = 0 ;
13073 bool temp1 = false ;
13074 long val2 ;
13075 int ecode2 = 0 ;
13076 int val3 ;
13077 int ecode3 = 0 ;
13078 PyObject * obj0 = 0 ;
13079 PyObject * obj1 = 0 ;
13080 PyObject * obj2 = 0 ;
13081 char * kwnames[] = {
13082 (char *) "name",(char *) "type",(char *) "index", NULL
13083 };
13084
13085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13086 {
13087 arg1 = wxString_in_helper(obj0);
13088 if (arg1 == NULL) SWIG_fail;
13089 temp1 = true;
13090 }
13091 if (obj1) {
13092 ecode2 = SWIG_AsVal_long(obj1, &val2);
13093 if (!SWIG_IsOK(ecode2)) {
13094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13095 }
13096 arg2 = static_cast< long >(val2);
13097 }
13098 if (obj2) {
13099 ecode3 = SWIG_AsVal_int(obj2, &val3);
13100 if (!SWIG_IsOK(ecode3)) {
13101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13102 }
13103 arg3 = static_cast< int >(val3);
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13108 wxPyEndAllowThreads(__tstate);
13109 if (PyErr_Occurred()) SWIG_fail;
13110 }
13111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13112 {
13113 if (temp1)
13114 delete arg1;
13115 }
13116 return resultobj;
13117 fail:
13118 {
13119 if (temp1)
13120 delete arg1;
13121 }
13122 return NULL;
13123 }
13124
13125
13126 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13127 PyObject *resultobj = 0;
13128 wxImage *arg1 = (wxImage *) 0 ;
13129 void *argp1 = 0 ;
13130 int res1 = 0 ;
13131 PyObject *swig_obj[1] ;
13132
13133 if (!args) SWIG_fail;
13134 swig_obj[0] = args;
13135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13136 if (!SWIG_IsOK(res1)) {
13137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13138 }
13139 arg1 = reinterpret_cast< wxImage * >(argp1);
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 delete arg1;
13143
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 resultobj = SWIG_Py_Void();
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj = 0;
13156 wxString *arg1 = 0 ;
13157 wxString *arg2 = 0 ;
13158 int arg3 = (int) -1 ;
13159 wxImage *result = 0 ;
13160 bool temp1 = false ;
13161 bool temp2 = false ;
13162 int val3 ;
13163 int ecode3 = 0 ;
13164 PyObject * obj0 = 0 ;
13165 PyObject * obj1 = 0 ;
13166 PyObject * obj2 = 0 ;
13167 char * kwnames[] = {
13168 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13169 };
13170
13171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13172 {
13173 arg1 = wxString_in_helper(obj0);
13174 if (arg1 == NULL) SWIG_fail;
13175 temp1 = true;
13176 }
13177 {
13178 arg2 = wxString_in_helper(obj1);
13179 if (arg2 == NULL) SWIG_fail;
13180 temp2 = true;
13181 }
13182 if (obj2) {
13183 ecode3 = SWIG_AsVal_int(obj2, &val3);
13184 if (!SWIG_IsOK(ecode3)) {
13185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13186 }
13187 arg3 = static_cast< int >(val3);
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13196 {
13197 if (temp1)
13198 delete arg1;
13199 }
13200 {
13201 if (temp2)
13202 delete arg2;
13203 }
13204 return resultobj;
13205 fail:
13206 {
13207 if (temp1)
13208 delete arg1;
13209 }
13210 {
13211 if (temp2)
13212 delete arg2;
13213 }
13214 return NULL;
13215 }
13216
13217
13218 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj = 0;
13220 wxInputStream *arg1 = 0 ;
13221 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13222 int arg3 = (int) -1 ;
13223 wxImage *result = 0 ;
13224 wxPyInputStream *temp1 ;
13225 bool created1 ;
13226 long val2 ;
13227 int ecode2 = 0 ;
13228 int val3 ;
13229 int ecode3 = 0 ;
13230 PyObject * obj0 = 0 ;
13231 PyObject * obj1 = 0 ;
13232 PyObject * obj2 = 0 ;
13233 char * kwnames[] = {
13234 (char *) "stream",(char *) "type",(char *) "index", NULL
13235 };
13236
13237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13238 {
13239 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13240 arg1 = temp1->m_wxis;
13241 created1 = false;
13242 } else {
13243 PyErr_Clear(); // clear the failure of the wxPyConvert above
13244 arg1 = wxPyCBInputStream_create(obj0, false);
13245 if (arg1 == NULL) {
13246 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13247 SWIG_fail;
13248 }
13249 created1 = true;
13250 }
13251 }
13252 if (obj1) {
13253 ecode2 = SWIG_AsVal_long(obj1, &val2);
13254 if (!SWIG_IsOK(ecode2)) {
13255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13256 }
13257 arg2 = static_cast< long >(val2);
13258 }
13259 if (obj2) {
13260 ecode3 = SWIG_AsVal_int(obj2, &val3);
13261 if (!SWIG_IsOK(ecode3)) {
13262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13263 }
13264 arg3 = static_cast< int >(val3);
13265 }
13266 {
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13269 wxPyEndAllowThreads(__tstate);
13270 if (PyErr_Occurred()) SWIG_fail;
13271 }
13272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13273 {
13274 if (created1) delete arg1;
13275 }
13276 return resultobj;
13277 fail:
13278 {
13279 if (created1) delete arg1;
13280 }
13281 return NULL;
13282 }
13283
13284
13285 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj = 0;
13287 wxInputStream *arg1 = 0 ;
13288 wxString *arg2 = 0 ;
13289 int arg3 = (int) -1 ;
13290 wxImage *result = 0 ;
13291 wxPyInputStream *temp1 ;
13292 bool created1 ;
13293 bool temp2 = false ;
13294 int val3 ;
13295 int ecode3 = 0 ;
13296 PyObject * obj0 = 0 ;
13297 PyObject * obj1 = 0 ;
13298 PyObject * obj2 = 0 ;
13299 char * kwnames[] = {
13300 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13301 };
13302
13303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13304 {
13305 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13306 arg1 = temp1->m_wxis;
13307 created1 = false;
13308 } else {
13309 PyErr_Clear(); // clear the failure of the wxPyConvert above
13310 arg1 = wxPyCBInputStream_create(obj0, false);
13311 if (arg1 == NULL) {
13312 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13313 SWIG_fail;
13314 }
13315 created1 = true;
13316 }
13317 }
13318 {
13319 arg2 = wxString_in_helper(obj1);
13320 if (arg2 == NULL) SWIG_fail;
13321 temp2 = true;
13322 }
13323 if (obj2) {
13324 ecode3 = SWIG_AsVal_int(obj2, &val3);
13325 if (!SWIG_IsOK(ecode3)) {
13326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13327 }
13328 arg3 = static_cast< int >(val3);
13329 }
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13337 {
13338 if (created1) delete arg1;
13339 }
13340 {
13341 if (temp2)
13342 delete arg2;
13343 }
13344 return resultobj;
13345 fail:
13346 {
13347 if (created1) delete arg1;
13348 }
13349 {
13350 if (temp2)
13351 delete arg2;
13352 }
13353 return NULL;
13354 }
13355
13356
13357 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13358 PyObject *resultobj = 0;
13359 int arg1 = (int) 0 ;
13360 int arg2 = (int) 0 ;
13361 bool arg3 = (bool) true ;
13362 wxImage *result = 0 ;
13363 int val1 ;
13364 int ecode1 = 0 ;
13365 int val2 ;
13366 int ecode2 = 0 ;
13367 bool val3 ;
13368 int ecode3 = 0 ;
13369 PyObject * obj0 = 0 ;
13370 PyObject * obj1 = 0 ;
13371 PyObject * obj2 = 0 ;
13372 char * kwnames[] = {
13373 (char *) "width",(char *) "height",(char *) "clear", NULL
13374 };
13375
13376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13377 if (obj0) {
13378 ecode1 = SWIG_AsVal_int(obj0, &val1);
13379 if (!SWIG_IsOK(ecode1)) {
13380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13381 }
13382 arg1 = static_cast< int >(val1);
13383 }
13384 if (obj1) {
13385 ecode2 = SWIG_AsVal_int(obj1, &val2);
13386 if (!SWIG_IsOK(ecode2)) {
13387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13388 }
13389 arg2 = static_cast< int >(val2);
13390 }
13391 if (obj2) {
13392 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13393 if (!SWIG_IsOK(ecode3)) {
13394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13395 }
13396 arg3 = static_cast< bool >(val3);
13397 }
13398 {
13399 PyThreadState* __tstate = wxPyBeginAllowThreads();
13400 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13405 return resultobj;
13406 fail:
13407 return NULL;
13408 }
13409
13410
13411 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13412 PyObject *resultobj = 0;
13413 wxBitmap *arg1 = 0 ;
13414 wxImage *result = 0 ;
13415 void *argp1 = 0 ;
13416 int res1 = 0 ;
13417 PyObject * obj0 = 0 ;
13418 char * kwnames[] = {
13419 (char *) "bitmap", NULL
13420 };
13421
13422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13423 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13424 if (!SWIG_IsOK(res1)) {
13425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13426 }
13427 if (!argp1) {
13428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13429 }
13430 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13431 {
13432 if (!wxPyCheckForApp()) SWIG_fail;
13433 PyThreadState* __tstate = wxPyBeginAllowThreads();
13434 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13446 PyObject *resultobj = 0;
13447 int arg1 ;
13448 int arg2 ;
13449 buffer arg3 ;
13450 int arg4 ;
13451 wxImage *result = 0 ;
13452 int val1 ;
13453 int ecode1 = 0 ;
13454 int val2 ;
13455 int ecode2 = 0 ;
13456 Py_ssize_t temp3 ;
13457 PyObject * obj0 = 0 ;
13458 PyObject * obj1 = 0 ;
13459 PyObject * obj2 = 0 ;
13460 char * kwnames[] = {
13461 (char *) "width",(char *) "height",(char *) "data", NULL
13462 };
13463
13464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13465 ecode1 = SWIG_AsVal_int(obj0, &val1);
13466 if (!SWIG_IsOK(ecode1)) {
13467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13468 }
13469 arg1 = static_cast< int >(val1);
13470 ecode2 = SWIG_AsVal_int(obj1, &val2);
13471 if (!SWIG_IsOK(ecode2)) {
13472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13473 }
13474 arg2 = static_cast< int >(val2);
13475 {
13476 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13477 arg4 = (int)temp3;
13478 }
13479 {
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13482 wxPyEndAllowThreads(__tstate);
13483 if (PyErr_Occurred()) SWIG_fail;
13484 }
13485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13486 return resultobj;
13487 fail:
13488 return NULL;
13489 }
13490
13491
13492 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13493 PyObject *resultobj = 0;
13494 int arg1 ;
13495 int arg2 ;
13496 buffer arg3 ;
13497 int arg4 ;
13498 buffer arg5 ;
13499 int arg6 ;
13500 wxImage *result = 0 ;
13501 int val1 ;
13502 int ecode1 = 0 ;
13503 int val2 ;
13504 int ecode2 = 0 ;
13505 Py_ssize_t temp3 ;
13506 Py_ssize_t temp5 ;
13507 PyObject * obj0 = 0 ;
13508 PyObject * obj1 = 0 ;
13509 PyObject * obj2 = 0 ;
13510 PyObject * obj3 = 0 ;
13511 char * kwnames[] = {
13512 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13513 };
13514
13515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13516 ecode1 = SWIG_AsVal_int(obj0, &val1);
13517 if (!SWIG_IsOK(ecode1)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13519 }
13520 arg1 = static_cast< int >(val1);
13521 ecode2 = SWIG_AsVal_int(obj1, &val2);
13522 if (!SWIG_IsOK(ecode2)) {
13523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13524 }
13525 arg2 = static_cast< int >(val2);
13526 {
13527 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13528 arg4 = (int)temp3;
13529 }
13530 {
13531 if (obj3 != Py_None) {
13532 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13533 arg6 = (int)temp5;
13534 }
13535 }
13536 {
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13539 wxPyEndAllowThreads(__tstate);
13540 if (PyErr_Occurred()) SWIG_fail;
13541 }
13542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13543 return resultobj;
13544 fail:
13545 return NULL;
13546 }
13547
13548
13549 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13550 PyObject *resultobj = 0;
13551 wxImage *arg1 = (wxImage *) 0 ;
13552 int arg2 ;
13553 int arg3 ;
13554 bool arg4 = (bool) true ;
13555 void *argp1 = 0 ;
13556 int res1 = 0 ;
13557 int val2 ;
13558 int ecode2 = 0 ;
13559 int val3 ;
13560 int ecode3 = 0 ;
13561 bool val4 ;
13562 int ecode4 = 0 ;
13563 PyObject * obj0 = 0 ;
13564 PyObject * obj1 = 0 ;
13565 PyObject * obj2 = 0 ;
13566 PyObject * obj3 = 0 ;
13567 char * kwnames[] = {
13568 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13569 };
13570
13571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13573 if (!SWIG_IsOK(res1)) {
13574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13575 }
13576 arg1 = reinterpret_cast< wxImage * >(argp1);
13577 ecode2 = SWIG_AsVal_int(obj1, &val2);
13578 if (!SWIG_IsOK(ecode2)) {
13579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13580 }
13581 arg2 = static_cast< int >(val2);
13582 ecode3 = SWIG_AsVal_int(obj2, &val3);
13583 if (!SWIG_IsOK(ecode3)) {
13584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13585 }
13586 arg3 = static_cast< int >(val3);
13587 if (obj3) {
13588 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13589 if (!SWIG_IsOK(ecode4)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13591 }
13592 arg4 = static_cast< bool >(val4);
13593 }
13594 {
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 (arg1)->Create(arg2,arg3,arg4);
13597 wxPyEndAllowThreads(__tstate);
13598 if (PyErr_Occurred()) SWIG_fail;
13599 }
13600 resultobj = SWIG_Py_Void();
13601 return resultobj;
13602 fail:
13603 return NULL;
13604 }
13605
13606
13607 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13608 PyObject *resultobj = 0;
13609 wxImage *arg1 = (wxImage *) 0 ;
13610 void *argp1 = 0 ;
13611 int res1 = 0 ;
13612 PyObject *swig_obj[1] ;
13613
13614 if (!args) SWIG_fail;
13615 swig_obj[0] = args;
13616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13617 if (!SWIG_IsOK(res1)) {
13618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13619 }
13620 arg1 = reinterpret_cast< wxImage * >(argp1);
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 (arg1)->Destroy();
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 resultobj = SWIG_Py_Void();
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj = 0;
13636 wxImage *arg1 = (wxImage *) 0 ;
13637 int arg2 ;
13638 int arg3 ;
13639 SwigValueWrapper<wxImage > result;
13640 void *argp1 = 0 ;
13641 int res1 = 0 ;
13642 int val2 ;
13643 int ecode2 = 0 ;
13644 int val3 ;
13645 int ecode3 = 0 ;
13646 PyObject * obj0 = 0 ;
13647 PyObject * obj1 = 0 ;
13648 PyObject * obj2 = 0 ;
13649 char * kwnames[] = {
13650 (char *) "self",(char *) "width",(char *) "height", NULL
13651 };
13652
13653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13655 if (!SWIG_IsOK(res1)) {
13656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13657 }
13658 arg1 = reinterpret_cast< wxImage * >(argp1);
13659 ecode2 = SWIG_AsVal_int(obj1, &val2);
13660 if (!SWIG_IsOK(ecode2)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13662 }
13663 arg2 = static_cast< int >(val2);
13664 ecode3 = SWIG_AsVal_int(obj2, &val3);
13665 if (!SWIG_IsOK(ecode3)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13667 }
13668 arg3 = static_cast< int >(val3);
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 result = (arg1)->Scale(arg2,arg3);
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj = 0;
13684 wxImage *arg1 = (wxImage *) 0 ;
13685 int arg2 ;
13686 int arg3 ;
13687 SwigValueWrapper<wxImage > result;
13688 void *argp1 = 0 ;
13689 int res1 = 0 ;
13690 int val2 ;
13691 int ecode2 = 0 ;
13692 int val3 ;
13693 int ecode3 = 0 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13705 }
13706 arg1 = reinterpret_cast< wxImage * >(argp1);
13707 ecode2 = SWIG_AsVal_int(obj1, &val2);
13708 if (!SWIG_IsOK(ecode2)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13710 }
13711 arg2 = static_cast< int >(val2);
13712 ecode3 = SWIG_AsVal_int(obj2, &val3);
13713 if (!SWIG_IsOK(ecode3)) {
13714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13715 }
13716 arg3 = static_cast< int >(val3);
13717 {
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13720 wxPyEndAllowThreads(__tstate);
13721 if (PyErr_Occurred()) SWIG_fail;
13722 }
13723 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13724 return resultobj;
13725 fail:
13726 return NULL;
13727 }
13728
13729
13730 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13731 PyObject *resultobj = 0;
13732 wxImage *arg1 = (wxImage *) 0 ;
13733 int arg2 ;
13734 int arg3 ;
13735 wxImage *result = 0 ;
13736 void *argp1 = 0 ;
13737 int res1 = 0 ;
13738 int val2 ;
13739 int ecode2 = 0 ;
13740 int val3 ;
13741 int ecode3 = 0 ;
13742 PyObject * obj0 = 0 ;
13743 PyObject * obj1 = 0 ;
13744 PyObject * obj2 = 0 ;
13745 char * kwnames[] = {
13746 (char *) "self",(char *) "width",(char *) "height", NULL
13747 };
13748
13749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13751 if (!SWIG_IsOK(res1)) {
13752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13753 }
13754 arg1 = reinterpret_cast< wxImage * >(argp1);
13755 ecode2 = SWIG_AsVal_int(obj1, &val2);
13756 if (!SWIG_IsOK(ecode2)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13758 }
13759 arg2 = static_cast< int >(val2);
13760 ecode3 = SWIG_AsVal_int(obj2, &val3);
13761 if (!SWIG_IsOK(ecode3)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13763 }
13764 arg3 = static_cast< int >(val3);
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 {
13768 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13769 result = (wxImage *) &_result_ref;
13770 }
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13775 return resultobj;
13776 fail:
13777 return NULL;
13778 }
13779
13780
13781 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13782 PyObject *resultobj = 0;
13783 wxImage *arg1 = (wxImage *) 0 ;
13784 wxSize *arg2 = 0 ;
13785 wxPoint *arg3 = 0 ;
13786 int arg4 = (int) -1 ;
13787 int arg5 = (int) -1 ;
13788 int arg6 = (int) -1 ;
13789 wxImage *result = 0 ;
13790 void *argp1 = 0 ;
13791 int res1 = 0 ;
13792 wxSize temp2 ;
13793 wxPoint temp3 ;
13794 int val4 ;
13795 int ecode4 = 0 ;
13796 int val5 ;
13797 int ecode5 = 0 ;
13798 int val6 ;
13799 int ecode6 = 0 ;
13800 PyObject * obj0 = 0 ;
13801 PyObject * obj1 = 0 ;
13802 PyObject * obj2 = 0 ;
13803 PyObject * obj3 = 0 ;
13804 PyObject * obj4 = 0 ;
13805 PyObject * obj5 = 0 ;
13806 char * kwnames[] = {
13807 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13808 };
13809
13810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13812 if (!SWIG_IsOK(res1)) {
13813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13814 }
13815 arg1 = reinterpret_cast< wxImage * >(argp1);
13816 {
13817 arg2 = &temp2;
13818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13819 }
13820 {
13821 arg3 = &temp3;
13822 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13823 }
13824 if (obj3) {
13825 ecode4 = SWIG_AsVal_int(obj3, &val4);
13826 if (!SWIG_IsOK(ecode4)) {
13827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13828 }
13829 arg4 = static_cast< int >(val4);
13830 }
13831 if (obj4) {
13832 ecode5 = SWIG_AsVal_int(obj4, &val5);
13833 if (!SWIG_IsOK(ecode5)) {
13834 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13835 }
13836 arg5 = static_cast< int >(val5);
13837 }
13838 if (obj5) {
13839 ecode6 = SWIG_AsVal_int(obj5, &val6);
13840 if (!SWIG_IsOK(ecode6)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13842 }
13843 arg6 = static_cast< int >(val6);
13844 }
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 {
13848 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13849 result = (wxImage *) &_result_ref;
13850 }
13851 wxPyEndAllowThreads(__tstate);
13852 if (PyErr_Occurred()) SWIG_fail;
13853 }
13854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13855 return resultobj;
13856 fail:
13857 return NULL;
13858 }
13859
13860
13861 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13862 PyObject *resultobj = 0;
13863 wxImage *arg1 = (wxImage *) 0 ;
13864 int arg2 ;
13865 int arg3 ;
13866 byte arg4 ;
13867 byte arg5 ;
13868 byte arg6 ;
13869 void *argp1 = 0 ;
13870 int res1 = 0 ;
13871 int val2 ;
13872 int ecode2 = 0 ;
13873 int val3 ;
13874 int ecode3 = 0 ;
13875 unsigned char val4 ;
13876 int ecode4 = 0 ;
13877 unsigned char val5 ;
13878 int ecode5 = 0 ;
13879 unsigned char val6 ;
13880 int ecode6 = 0 ;
13881 PyObject * obj0 = 0 ;
13882 PyObject * obj1 = 0 ;
13883 PyObject * obj2 = 0 ;
13884 PyObject * obj3 = 0 ;
13885 PyObject * obj4 = 0 ;
13886 PyObject * obj5 = 0 ;
13887 char * kwnames[] = {
13888 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13889 };
13890
13891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13893 if (!SWIG_IsOK(res1)) {
13894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13895 }
13896 arg1 = reinterpret_cast< wxImage * >(argp1);
13897 ecode2 = SWIG_AsVal_int(obj1, &val2);
13898 if (!SWIG_IsOK(ecode2)) {
13899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13900 }
13901 arg2 = static_cast< int >(val2);
13902 ecode3 = SWIG_AsVal_int(obj2, &val3);
13903 if (!SWIG_IsOK(ecode3)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13905 }
13906 arg3 = static_cast< int >(val3);
13907 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13908 if (!SWIG_IsOK(ecode4)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13910 }
13911 arg4 = static_cast< byte >(val4);
13912 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13913 if (!SWIG_IsOK(ecode5)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13915 }
13916 arg5 = static_cast< byte >(val5);
13917 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13918 if (!SWIG_IsOK(ecode6)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13920 }
13921 arg6 = static_cast< byte >(val6);
13922 {
13923 PyThreadState* __tstate = wxPyBeginAllowThreads();
13924 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13925 wxPyEndAllowThreads(__tstate);
13926 if (PyErr_Occurred()) SWIG_fail;
13927 }
13928 resultobj = SWIG_Py_Void();
13929 return resultobj;
13930 fail:
13931 return NULL;
13932 }
13933
13934
13935 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13936 PyObject *resultobj = 0;
13937 wxImage *arg1 = (wxImage *) 0 ;
13938 wxRect *arg2 = 0 ;
13939 byte arg3 ;
13940 byte arg4 ;
13941 byte arg5 ;
13942 void *argp1 = 0 ;
13943 int res1 = 0 ;
13944 wxRect temp2 ;
13945 unsigned char val3 ;
13946 int ecode3 = 0 ;
13947 unsigned char val4 ;
13948 int ecode4 = 0 ;
13949 unsigned char val5 ;
13950 int ecode5 = 0 ;
13951 PyObject * obj0 = 0 ;
13952 PyObject * obj1 = 0 ;
13953 PyObject * obj2 = 0 ;
13954 PyObject * obj3 = 0 ;
13955 PyObject * obj4 = 0 ;
13956 char * kwnames[] = {
13957 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13958 };
13959
13960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13962 if (!SWIG_IsOK(res1)) {
13963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13964 }
13965 arg1 = reinterpret_cast< wxImage * >(argp1);
13966 {
13967 arg2 = &temp2;
13968 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13969 }
13970 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13971 if (!SWIG_IsOK(ecode3)) {
13972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13973 }
13974 arg3 = static_cast< byte >(val3);
13975 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13976 if (!SWIG_IsOK(ecode4)) {
13977 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13978 }
13979 arg4 = static_cast< byte >(val4);
13980 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13981 if (!SWIG_IsOK(ecode5)) {
13982 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13983 }
13984 arg5 = static_cast< byte >(val5);
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 resultobj = SWIG_Py_Void();
13992 return resultobj;
13993 fail:
13994 return NULL;
13995 }
13996
13997
13998 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13999 PyObject *resultobj = 0;
14000 wxImage *arg1 = (wxImage *) 0 ;
14001 int arg2 ;
14002 int arg3 ;
14003 byte result;
14004 void *argp1 = 0 ;
14005 int res1 = 0 ;
14006 int val2 ;
14007 int ecode2 = 0 ;
14008 int val3 ;
14009 int ecode3 = 0 ;
14010 PyObject * obj0 = 0 ;
14011 PyObject * obj1 = 0 ;
14012 PyObject * obj2 = 0 ;
14013 char * kwnames[] = {
14014 (char *) "self",(char *) "x",(char *) "y", NULL
14015 };
14016
14017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14019 if (!SWIG_IsOK(res1)) {
14020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14021 }
14022 arg1 = reinterpret_cast< wxImage * >(argp1);
14023 ecode2 = SWIG_AsVal_int(obj1, &val2);
14024 if (!SWIG_IsOK(ecode2)) {
14025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14026 }
14027 arg2 = static_cast< int >(val2);
14028 ecode3 = SWIG_AsVal_int(obj2, &val3);
14029 if (!SWIG_IsOK(ecode3)) {
14030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14031 }
14032 arg3 = static_cast< int >(val3);
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 result = (byte)(arg1)->GetRed(arg2,arg3);
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14040 return resultobj;
14041 fail:
14042 return NULL;
14043 }
14044
14045
14046 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14047 PyObject *resultobj = 0;
14048 wxImage *arg1 = (wxImage *) 0 ;
14049 int arg2 ;
14050 int arg3 ;
14051 byte result;
14052 void *argp1 = 0 ;
14053 int res1 = 0 ;
14054 int val2 ;
14055 int ecode2 = 0 ;
14056 int val3 ;
14057 int ecode3 = 0 ;
14058 PyObject * obj0 = 0 ;
14059 PyObject * obj1 = 0 ;
14060 PyObject * obj2 = 0 ;
14061 char * kwnames[] = {
14062 (char *) "self",(char *) "x",(char *) "y", NULL
14063 };
14064
14065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14067 if (!SWIG_IsOK(res1)) {
14068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14069 }
14070 arg1 = reinterpret_cast< wxImage * >(argp1);
14071 ecode2 = SWIG_AsVal_int(obj1, &val2);
14072 if (!SWIG_IsOK(ecode2)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14074 }
14075 arg2 = static_cast< int >(val2);
14076 ecode3 = SWIG_AsVal_int(obj2, &val3);
14077 if (!SWIG_IsOK(ecode3)) {
14078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14079 }
14080 arg3 = static_cast< int >(val3);
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 result = (byte)(arg1)->GetGreen(arg2,arg3);
14084 wxPyEndAllowThreads(__tstate);
14085 if (PyErr_Occurred()) SWIG_fail;
14086 }
14087 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14088 return resultobj;
14089 fail:
14090 return NULL;
14091 }
14092
14093
14094 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj = 0;
14096 wxImage *arg1 = (wxImage *) 0 ;
14097 int arg2 ;
14098 int arg3 ;
14099 byte result;
14100 void *argp1 = 0 ;
14101 int res1 = 0 ;
14102 int val2 ;
14103 int ecode2 = 0 ;
14104 int val3 ;
14105 int ecode3 = 0 ;
14106 PyObject * obj0 = 0 ;
14107 PyObject * obj1 = 0 ;
14108 PyObject * obj2 = 0 ;
14109 char * kwnames[] = {
14110 (char *) "self",(char *) "x",(char *) "y", NULL
14111 };
14112
14113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14115 if (!SWIG_IsOK(res1)) {
14116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14117 }
14118 arg1 = reinterpret_cast< wxImage * >(argp1);
14119 ecode2 = SWIG_AsVal_int(obj1, &val2);
14120 if (!SWIG_IsOK(ecode2)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14122 }
14123 arg2 = static_cast< int >(val2);
14124 ecode3 = SWIG_AsVal_int(obj2, &val3);
14125 if (!SWIG_IsOK(ecode3)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14127 }
14128 arg3 = static_cast< int >(val3);
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 result = (byte)(arg1)->GetBlue(arg2,arg3);
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj = 0;
14144 wxImage *arg1 = (wxImage *) 0 ;
14145 int arg2 ;
14146 int arg3 ;
14147 byte arg4 ;
14148 void *argp1 = 0 ;
14149 int res1 = 0 ;
14150 int val2 ;
14151 int ecode2 = 0 ;
14152 int val3 ;
14153 int ecode3 = 0 ;
14154 unsigned char val4 ;
14155 int ecode4 = 0 ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 PyObject * obj2 = 0 ;
14159 PyObject * obj3 = 0 ;
14160 char * kwnames[] = {
14161 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14162 };
14163
14164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14166 if (!SWIG_IsOK(res1)) {
14167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14168 }
14169 arg1 = reinterpret_cast< wxImage * >(argp1);
14170 ecode2 = SWIG_AsVal_int(obj1, &val2);
14171 if (!SWIG_IsOK(ecode2)) {
14172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14173 }
14174 arg2 = static_cast< int >(val2);
14175 ecode3 = SWIG_AsVal_int(obj2, &val3);
14176 if (!SWIG_IsOK(ecode3)) {
14177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14178 }
14179 arg3 = static_cast< int >(val3);
14180 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14181 if (!SWIG_IsOK(ecode4)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14183 }
14184 arg4 = static_cast< byte >(val4);
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 (arg1)->SetAlpha(arg2,arg3,arg4);
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 resultobj = SWIG_Py_Void();
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj = 0;
14200 wxImage *arg1 = (wxImage *) 0 ;
14201 int arg2 ;
14202 int arg3 ;
14203 byte result;
14204 void *argp1 = 0 ;
14205 int res1 = 0 ;
14206 int val2 ;
14207 int ecode2 = 0 ;
14208 int val3 ;
14209 int ecode3 = 0 ;
14210 PyObject * obj0 = 0 ;
14211 PyObject * obj1 = 0 ;
14212 PyObject * obj2 = 0 ;
14213 char * kwnames[] = {
14214 (char *) "self",(char *) "x",(char *) "y", NULL
14215 };
14216
14217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14219 if (!SWIG_IsOK(res1)) {
14220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14221 }
14222 arg1 = reinterpret_cast< wxImage * >(argp1);
14223 ecode2 = SWIG_AsVal_int(obj1, &val2);
14224 if (!SWIG_IsOK(ecode2)) {
14225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14226 }
14227 arg2 = static_cast< int >(val2);
14228 ecode3 = SWIG_AsVal_int(obj2, &val3);
14229 if (!SWIG_IsOK(ecode3)) {
14230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14231 }
14232 arg3 = static_cast< int >(val3);
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14236 wxPyEndAllowThreads(__tstate);
14237 if (PyErr_Occurred()) SWIG_fail;
14238 }
14239 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14247 PyObject *resultobj = 0;
14248 wxImage *arg1 = (wxImage *) 0 ;
14249 bool result;
14250 void *argp1 = 0 ;
14251 int res1 = 0 ;
14252 PyObject *swig_obj[1] ;
14253
14254 if (!args) SWIG_fail;
14255 swig_obj[0] = args;
14256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14257 if (!SWIG_IsOK(res1)) {
14258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14259 }
14260 arg1 = reinterpret_cast< wxImage * >(argp1);
14261 {
14262 PyThreadState* __tstate = wxPyBeginAllowThreads();
14263 result = (bool)(arg1)->HasAlpha();
14264 wxPyEndAllowThreads(__tstate);
14265 if (PyErr_Occurred()) SWIG_fail;
14266 }
14267 {
14268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14269 }
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14277 PyObject *resultobj = 0;
14278 wxImage *arg1 = (wxImage *) 0 ;
14279 void *argp1 = 0 ;
14280 int res1 = 0 ;
14281 PyObject *swig_obj[1] ;
14282
14283 if (!args) SWIG_fail;
14284 swig_obj[0] = args;
14285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14286 if (!SWIG_IsOK(res1)) {
14287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14288 }
14289 arg1 = reinterpret_cast< wxImage * >(argp1);
14290 {
14291 PyThreadState* __tstate = wxPyBeginAllowThreads();
14292 (arg1)->InitAlpha();
14293 wxPyEndAllowThreads(__tstate);
14294 if (PyErr_Occurred()) SWIG_fail;
14295 }
14296 resultobj = SWIG_Py_Void();
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj = 0;
14305 wxImage *arg1 = (wxImage *) 0 ;
14306 int arg2 ;
14307 int arg3 ;
14308 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14309 bool result;
14310 void *argp1 = 0 ;
14311 int res1 = 0 ;
14312 int val2 ;
14313 int ecode2 = 0 ;
14314 int val3 ;
14315 int ecode3 = 0 ;
14316 unsigned char val4 ;
14317 int ecode4 = 0 ;
14318 PyObject * obj0 = 0 ;
14319 PyObject * obj1 = 0 ;
14320 PyObject * obj2 = 0 ;
14321 PyObject * obj3 = 0 ;
14322 char * kwnames[] = {
14323 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14324 };
14325
14326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14328 if (!SWIG_IsOK(res1)) {
14329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14330 }
14331 arg1 = reinterpret_cast< wxImage * >(argp1);
14332 ecode2 = SWIG_AsVal_int(obj1, &val2);
14333 if (!SWIG_IsOK(ecode2)) {
14334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14335 }
14336 arg2 = static_cast< int >(val2);
14337 ecode3 = SWIG_AsVal_int(obj2, &val3);
14338 if (!SWIG_IsOK(ecode3)) {
14339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14340 }
14341 arg3 = static_cast< int >(val3);
14342 if (obj3) {
14343 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14344 if (!SWIG_IsOK(ecode4)) {
14345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14346 }
14347 arg4 = static_cast< byte >(val4);
14348 }
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 {
14356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14357 }
14358 return resultobj;
14359 fail:
14360 return NULL;
14361 }
14362
14363
14364 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14365 PyObject *resultobj = 0;
14366 wxImage *arg1 = (wxImage *) 0 ;
14367 byte *arg2 = (byte *) 0 ;
14368 byte *arg3 = (byte *) 0 ;
14369 byte *arg4 = (byte *) 0 ;
14370 byte arg5 = (byte) 0 ;
14371 byte arg6 = (byte) 0 ;
14372 byte arg7 = (byte) 0 ;
14373 bool result;
14374 void *argp1 = 0 ;
14375 int res1 = 0 ;
14376 byte temp2 ;
14377 int res2 = SWIG_TMPOBJ ;
14378 byte temp3 ;
14379 int res3 = SWIG_TMPOBJ ;
14380 byte temp4 ;
14381 int res4 = SWIG_TMPOBJ ;
14382 unsigned char val5 ;
14383 int ecode5 = 0 ;
14384 unsigned char val6 ;
14385 int ecode6 = 0 ;
14386 unsigned char val7 ;
14387 int ecode7 = 0 ;
14388 PyObject * obj0 = 0 ;
14389 PyObject * obj1 = 0 ;
14390 PyObject * obj2 = 0 ;
14391 PyObject * obj3 = 0 ;
14392 char * kwnames[] = {
14393 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14394 };
14395
14396 arg2 = &temp2;
14397 arg3 = &temp3;
14398 arg4 = &temp4;
14399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14401 if (!SWIG_IsOK(res1)) {
14402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14403 }
14404 arg1 = reinterpret_cast< wxImage * >(argp1);
14405 if (obj1) {
14406 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14407 if (!SWIG_IsOK(ecode5)) {
14408 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14409 }
14410 arg5 = static_cast< byte >(val5);
14411 }
14412 if (obj2) {
14413 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14414 if (!SWIG_IsOK(ecode6)) {
14415 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14416 }
14417 arg6 = static_cast< byte >(val6);
14418 }
14419 if (obj3) {
14420 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14421 if (!SWIG_IsOK(ecode7)) {
14422 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14423 }
14424 arg7 = static_cast< byte >(val7);
14425 }
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 {
14433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14434 }
14435 if (SWIG_IsTmpObj(res2)) {
14436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14437 } else {
14438 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14440 }
14441 if (SWIG_IsTmpObj(res3)) {
14442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14443 } else {
14444 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14445 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14446 }
14447 if (SWIG_IsTmpObj(res4)) {
14448 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14449 } else {
14450 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14451 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14452 }
14453 return resultobj;
14454 fail:
14455 return NULL;
14456 }
14457
14458
14459 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj = 0;
14461 wxImage *arg1 = (wxImage *) 0 ;
14462 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14463 bool result;
14464 void *argp1 = 0 ;
14465 int res1 = 0 ;
14466 unsigned char val2 ;
14467 int ecode2 = 0 ;
14468 PyObject * obj0 = 0 ;
14469 PyObject * obj1 = 0 ;
14470 char * kwnames[] = {
14471 (char *) "self",(char *) "threshold", NULL
14472 };
14473
14474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14476 if (!SWIG_IsOK(res1)) {
14477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14478 }
14479 arg1 = reinterpret_cast< wxImage * >(argp1);
14480 if (obj1) {
14481 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14482 if (!SWIG_IsOK(ecode2)) {
14483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14484 }
14485 arg2 = static_cast< byte >(val2);
14486 }
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 {
14494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14495 }
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj = 0;
14504 wxImage *arg1 = (wxImage *) 0 ;
14505 byte arg2 ;
14506 byte arg3 ;
14507 byte arg4 ;
14508 bool result;
14509 void *argp1 = 0 ;
14510 int res1 = 0 ;
14511 unsigned char val2 ;
14512 int ecode2 = 0 ;
14513 unsigned char val3 ;
14514 int ecode3 = 0 ;
14515 unsigned char val4 ;
14516 int ecode4 = 0 ;
14517 PyObject * obj0 = 0 ;
14518 PyObject * obj1 = 0 ;
14519 PyObject * obj2 = 0 ;
14520 PyObject * obj3 = 0 ;
14521 char * kwnames[] = {
14522 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14523 };
14524
14525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14527 if (!SWIG_IsOK(res1)) {
14528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14529 }
14530 arg1 = reinterpret_cast< wxImage * >(argp1);
14531 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14532 if (!SWIG_IsOK(ecode2)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14534 }
14535 arg2 = static_cast< byte >(val2);
14536 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14537 if (!SWIG_IsOK(ecode3)) {
14538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14539 }
14540 arg3 = static_cast< byte >(val3);
14541 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14542 if (!SWIG_IsOK(ecode4)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14544 }
14545 arg4 = static_cast< byte >(val4);
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14549 wxPyEndAllowThreads(__tstate);
14550 if (PyErr_Occurred()) SWIG_fail;
14551 }
14552 {
14553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14554 }
14555 return resultobj;
14556 fail:
14557 return NULL;
14558 }
14559
14560
14561 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14562 PyObject *resultobj = 0;
14563 wxImage *arg1 = (wxImage *) 0 ;
14564 wxImage *arg2 = 0 ;
14565 byte arg3 ;
14566 byte arg4 ;
14567 byte arg5 ;
14568 bool result;
14569 void *argp1 = 0 ;
14570 int res1 = 0 ;
14571 void *argp2 = 0 ;
14572 int res2 = 0 ;
14573 unsigned char val3 ;
14574 int ecode3 = 0 ;
14575 unsigned char val4 ;
14576 int ecode4 = 0 ;
14577 unsigned char val5 ;
14578 int ecode5 = 0 ;
14579 PyObject * obj0 = 0 ;
14580 PyObject * obj1 = 0 ;
14581 PyObject * obj2 = 0 ;
14582 PyObject * obj3 = 0 ;
14583 PyObject * obj4 = 0 ;
14584 char * kwnames[] = {
14585 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14586 };
14587
14588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14590 if (!SWIG_IsOK(res1)) {
14591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14592 }
14593 arg1 = reinterpret_cast< wxImage * >(argp1);
14594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14595 if (!SWIG_IsOK(res2)) {
14596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14597 }
14598 if (!argp2) {
14599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14600 }
14601 arg2 = reinterpret_cast< wxImage * >(argp2);
14602 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14603 if (!SWIG_IsOK(ecode3)) {
14604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14605 }
14606 arg3 = static_cast< byte >(val3);
14607 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14608 if (!SWIG_IsOK(ecode4)) {
14609 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14610 }
14611 arg4 = static_cast< byte >(val4);
14612 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14613 if (!SWIG_IsOK(ecode5)) {
14614 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14615 }
14616 arg5 = static_cast< byte >(val5);
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14620 wxPyEndAllowThreads(__tstate);
14621 if (PyErr_Occurred()) SWIG_fail;
14622 }
14623 {
14624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14625 }
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj = 0;
14634 wxString *arg1 = 0 ;
14635 bool result;
14636 bool temp1 = false ;
14637 PyObject * obj0 = 0 ;
14638 char * kwnames[] = {
14639 (char *) "filename", NULL
14640 };
14641
14642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14643 {
14644 arg1 = wxString_in_helper(obj0);
14645 if (arg1 == NULL) SWIG_fail;
14646 temp1 = true;
14647 }
14648 {
14649 PyThreadState* __tstate = wxPyBeginAllowThreads();
14650 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14651 wxPyEndAllowThreads(__tstate);
14652 if (PyErr_Occurred()) SWIG_fail;
14653 }
14654 {
14655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14656 }
14657 {
14658 if (temp1)
14659 delete arg1;
14660 }
14661 return resultobj;
14662 fail:
14663 {
14664 if (temp1)
14665 delete arg1;
14666 }
14667 return NULL;
14668 }
14669
14670
14671 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj = 0;
14673 wxString *arg1 = 0 ;
14674 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14675 int result;
14676 bool temp1 = false ;
14677 long val2 ;
14678 int ecode2 = 0 ;
14679 PyObject * obj0 = 0 ;
14680 PyObject * obj1 = 0 ;
14681 char * kwnames[] = {
14682 (char *) "filename",(char *) "type", NULL
14683 };
14684
14685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14686 {
14687 arg1 = wxString_in_helper(obj0);
14688 if (arg1 == NULL) SWIG_fail;
14689 temp1 = true;
14690 }
14691 if (obj1) {
14692 ecode2 = SWIG_AsVal_long(obj1, &val2);
14693 if (!SWIG_IsOK(ecode2)) {
14694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14695 }
14696 arg2 = static_cast< long >(val2);
14697 }
14698 {
14699 PyThreadState* __tstate = wxPyBeginAllowThreads();
14700 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14701 wxPyEndAllowThreads(__tstate);
14702 if (PyErr_Occurred()) SWIG_fail;
14703 }
14704 resultobj = SWIG_From_int(static_cast< int >(result));
14705 {
14706 if (temp1)
14707 delete arg1;
14708 }
14709 return resultobj;
14710 fail:
14711 {
14712 if (temp1)
14713 delete arg1;
14714 }
14715 return NULL;
14716 }
14717
14718
14719 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14720 PyObject *resultobj = 0;
14721 wxImage *arg1 = (wxImage *) 0 ;
14722 wxString *arg2 = 0 ;
14723 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14724 int arg4 = (int) -1 ;
14725 bool result;
14726 void *argp1 = 0 ;
14727 int res1 = 0 ;
14728 bool temp2 = false ;
14729 long val3 ;
14730 int ecode3 = 0 ;
14731 int val4 ;
14732 int ecode4 = 0 ;
14733 PyObject * obj0 = 0 ;
14734 PyObject * obj1 = 0 ;
14735 PyObject * obj2 = 0 ;
14736 PyObject * obj3 = 0 ;
14737 char * kwnames[] = {
14738 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14739 };
14740
14741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14745 }
14746 arg1 = reinterpret_cast< wxImage * >(argp1);
14747 {
14748 arg2 = wxString_in_helper(obj1);
14749 if (arg2 == NULL) SWIG_fail;
14750 temp2 = true;
14751 }
14752 if (obj2) {
14753 ecode3 = SWIG_AsVal_long(obj2, &val3);
14754 if (!SWIG_IsOK(ecode3)) {
14755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14756 }
14757 arg3 = static_cast< long >(val3);
14758 }
14759 if (obj3) {
14760 ecode4 = SWIG_AsVal_int(obj3, &val4);
14761 if (!SWIG_IsOK(ecode4)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14763 }
14764 arg4 = static_cast< int >(val4);
14765 }
14766 {
14767 PyThreadState* __tstate = wxPyBeginAllowThreads();
14768 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14769 wxPyEndAllowThreads(__tstate);
14770 if (PyErr_Occurred()) SWIG_fail;
14771 }
14772 {
14773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14774 }
14775 {
14776 if (temp2)
14777 delete arg2;
14778 }
14779 return resultobj;
14780 fail:
14781 {
14782 if (temp2)
14783 delete arg2;
14784 }
14785 return NULL;
14786 }
14787
14788
14789 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14790 PyObject *resultobj = 0;
14791 wxImage *arg1 = (wxImage *) 0 ;
14792 wxString *arg2 = 0 ;
14793 wxString *arg3 = 0 ;
14794 int arg4 = (int) -1 ;
14795 bool result;
14796 void *argp1 = 0 ;
14797 int res1 = 0 ;
14798 bool temp2 = false ;
14799 bool temp3 = false ;
14800 int val4 ;
14801 int ecode4 = 0 ;
14802 PyObject * obj0 = 0 ;
14803 PyObject * obj1 = 0 ;
14804 PyObject * obj2 = 0 ;
14805 PyObject * obj3 = 0 ;
14806 char * kwnames[] = {
14807 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14808 };
14809
14810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14812 if (!SWIG_IsOK(res1)) {
14813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14814 }
14815 arg1 = reinterpret_cast< wxImage * >(argp1);
14816 {
14817 arg2 = wxString_in_helper(obj1);
14818 if (arg2 == NULL) SWIG_fail;
14819 temp2 = true;
14820 }
14821 {
14822 arg3 = wxString_in_helper(obj2);
14823 if (arg3 == NULL) SWIG_fail;
14824 temp3 = true;
14825 }
14826 if (obj3) {
14827 ecode4 = SWIG_AsVal_int(obj3, &val4);
14828 if (!SWIG_IsOK(ecode4)) {
14829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14830 }
14831 arg4 = static_cast< int >(val4);
14832 }
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 {
14840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14841 }
14842 {
14843 if (temp2)
14844 delete arg2;
14845 }
14846 {
14847 if (temp3)
14848 delete arg3;
14849 }
14850 return resultobj;
14851 fail:
14852 {
14853 if (temp2)
14854 delete arg2;
14855 }
14856 {
14857 if (temp3)
14858 delete arg3;
14859 }
14860 return NULL;
14861 }
14862
14863
14864 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14865 PyObject *resultobj = 0;
14866 wxImage *arg1 = (wxImage *) 0 ;
14867 wxString *arg2 = 0 ;
14868 int arg3 ;
14869 bool result;
14870 void *argp1 = 0 ;
14871 int res1 = 0 ;
14872 bool temp2 = false ;
14873 int val3 ;
14874 int ecode3 = 0 ;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 PyObject * obj2 = 0 ;
14878 char * kwnames[] = {
14879 (char *) "self",(char *) "name",(char *) "type", NULL
14880 };
14881
14882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14884 if (!SWIG_IsOK(res1)) {
14885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14886 }
14887 arg1 = reinterpret_cast< wxImage * >(argp1);
14888 {
14889 arg2 = wxString_in_helper(obj1);
14890 if (arg2 == NULL) SWIG_fail;
14891 temp2 = true;
14892 }
14893 ecode3 = SWIG_AsVal_int(obj2, &val3);
14894 if (!SWIG_IsOK(ecode3)) {
14895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14896 }
14897 arg3 = static_cast< int >(val3);
14898 {
14899 PyThreadState* __tstate = wxPyBeginAllowThreads();
14900 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 {
14905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14906 }
14907 {
14908 if (temp2)
14909 delete arg2;
14910 }
14911 return resultobj;
14912 fail:
14913 {
14914 if (temp2)
14915 delete arg2;
14916 }
14917 return NULL;
14918 }
14919
14920
14921 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14922 PyObject *resultobj = 0;
14923 wxImage *arg1 = (wxImage *) 0 ;
14924 wxString *arg2 = 0 ;
14925 wxString *arg3 = 0 ;
14926 bool result;
14927 void *argp1 = 0 ;
14928 int res1 = 0 ;
14929 bool temp2 = false ;
14930 bool temp3 = false ;
14931 PyObject * obj0 = 0 ;
14932 PyObject * obj1 = 0 ;
14933 PyObject * obj2 = 0 ;
14934 char * kwnames[] = {
14935 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14936 };
14937
14938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14940 if (!SWIG_IsOK(res1)) {
14941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14942 }
14943 arg1 = reinterpret_cast< wxImage * >(argp1);
14944 {
14945 arg2 = wxString_in_helper(obj1);
14946 if (arg2 == NULL) SWIG_fail;
14947 temp2 = true;
14948 }
14949 {
14950 arg3 = wxString_in_helper(obj2);
14951 if (arg3 == NULL) SWIG_fail;
14952 temp3 = true;
14953 }
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 {
14961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14962 }
14963 {
14964 if (temp2)
14965 delete arg2;
14966 }
14967 {
14968 if (temp3)
14969 delete arg3;
14970 }
14971 return resultobj;
14972 fail:
14973 {
14974 if (temp2)
14975 delete arg2;
14976 }
14977 {
14978 if (temp3)
14979 delete arg3;
14980 }
14981 return NULL;
14982 }
14983
14984
14985 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14986 PyObject *resultobj = 0;
14987 wxInputStream *arg1 = 0 ;
14988 bool result;
14989 wxPyInputStream *temp1 ;
14990 bool created1 ;
14991 PyObject * obj0 = 0 ;
14992 char * kwnames[] = {
14993 (char *) "stream", NULL
14994 };
14995
14996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14997 {
14998 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14999 arg1 = temp1->m_wxis;
15000 created1 = false;
15001 } else {
15002 PyErr_Clear(); // clear the failure of the wxPyConvert above
15003 arg1 = wxPyCBInputStream_create(obj0, false);
15004 if (arg1 == NULL) {
15005 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15006 SWIG_fail;
15007 }
15008 created1 = true;
15009 }
15010 }
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 result = (bool)wxImage::CanRead(*arg1);
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 {
15018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15019 }
15020 {
15021 if (created1) delete arg1;
15022 }
15023 return resultobj;
15024 fail:
15025 {
15026 if (created1) delete arg1;
15027 }
15028 return NULL;
15029 }
15030
15031
15032 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15033 PyObject *resultobj = 0;
15034 wxImage *arg1 = (wxImage *) 0 ;
15035 wxInputStream *arg2 = 0 ;
15036 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15037 int arg4 = (int) -1 ;
15038 bool result;
15039 void *argp1 = 0 ;
15040 int res1 = 0 ;
15041 wxPyInputStream *temp2 ;
15042 bool created2 ;
15043 long val3 ;
15044 int ecode3 = 0 ;
15045 int val4 ;
15046 int ecode4 = 0 ;
15047 PyObject * obj0 = 0 ;
15048 PyObject * obj1 = 0 ;
15049 PyObject * obj2 = 0 ;
15050 PyObject * obj3 = 0 ;
15051 char * kwnames[] = {
15052 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15053 };
15054
15055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15057 if (!SWIG_IsOK(res1)) {
15058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15059 }
15060 arg1 = reinterpret_cast< wxImage * >(argp1);
15061 {
15062 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15063 arg2 = temp2->m_wxis;
15064 created2 = false;
15065 } else {
15066 PyErr_Clear(); // clear the failure of the wxPyConvert above
15067 arg2 = wxPyCBInputStream_create(obj1, false);
15068 if (arg2 == NULL) {
15069 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15070 SWIG_fail;
15071 }
15072 created2 = true;
15073 }
15074 }
15075 if (obj2) {
15076 ecode3 = SWIG_AsVal_long(obj2, &val3);
15077 if (!SWIG_IsOK(ecode3)) {
15078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15079 }
15080 arg3 = static_cast< long >(val3);
15081 }
15082 if (obj3) {
15083 ecode4 = SWIG_AsVal_int(obj3, &val4);
15084 if (!SWIG_IsOK(ecode4)) {
15085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15086 }
15087 arg4 = static_cast< int >(val4);
15088 }
15089 {
15090 PyThreadState* __tstate = wxPyBeginAllowThreads();
15091 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15092 wxPyEndAllowThreads(__tstate);
15093 if (PyErr_Occurred()) SWIG_fail;
15094 }
15095 {
15096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15097 }
15098 {
15099 if (created2) delete arg2;
15100 }
15101 return resultobj;
15102 fail:
15103 {
15104 if (created2) delete arg2;
15105 }
15106 return NULL;
15107 }
15108
15109
15110 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15111 PyObject *resultobj = 0;
15112 wxImage *arg1 = (wxImage *) 0 ;
15113 wxInputStream *arg2 = 0 ;
15114 wxString *arg3 = 0 ;
15115 int arg4 = (int) -1 ;
15116 bool result;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 wxPyInputStream *temp2 ;
15120 bool created2 ;
15121 bool temp3 = false ;
15122 int val4 ;
15123 int ecode4 = 0 ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 PyObject * obj3 = 0 ;
15128 char * kwnames[] = {
15129 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15130 };
15131
15132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15134 if (!SWIG_IsOK(res1)) {
15135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15136 }
15137 arg1 = reinterpret_cast< wxImage * >(argp1);
15138 {
15139 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15140 arg2 = temp2->m_wxis;
15141 created2 = false;
15142 } else {
15143 PyErr_Clear(); // clear the failure of the wxPyConvert above
15144 arg2 = wxPyCBInputStream_create(obj1, false);
15145 if (arg2 == NULL) {
15146 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15147 SWIG_fail;
15148 }
15149 created2 = true;
15150 }
15151 }
15152 {
15153 arg3 = wxString_in_helper(obj2);
15154 if (arg3 == NULL) SWIG_fail;
15155 temp3 = true;
15156 }
15157 if (obj3) {
15158 ecode4 = SWIG_AsVal_int(obj3, &val4);
15159 if (!SWIG_IsOK(ecode4)) {
15160 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15161 }
15162 arg4 = static_cast< int >(val4);
15163 }
15164 {
15165 PyThreadState* __tstate = wxPyBeginAllowThreads();
15166 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15167 wxPyEndAllowThreads(__tstate);
15168 if (PyErr_Occurred()) SWIG_fail;
15169 }
15170 {
15171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15172 }
15173 {
15174 if (created2) delete arg2;
15175 }
15176 {
15177 if (temp3)
15178 delete arg3;
15179 }
15180 return resultobj;
15181 fail:
15182 {
15183 if (created2) delete arg2;
15184 }
15185 {
15186 if (temp3)
15187 delete arg3;
15188 }
15189 return NULL;
15190 }
15191
15192
15193 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15194 PyObject *resultobj = 0;
15195 wxImage *arg1 = (wxImage *) 0 ;
15196 bool result;
15197 void *argp1 = 0 ;
15198 int res1 = 0 ;
15199 PyObject *swig_obj[1] ;
15200
15201 if (!args) SWIG_fail;
15202 swig_obj[0] = args;
15203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15204 if (!SWIG_IsOK(res1)) {
15205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15206 }
15207 arg1 = reinterpret_cast< wxImage * >(argp1);
15208 {
15209 PyThreadState* __tstate = wxPyBeginAllowThreads();
15210 result = (bool)(arg1)->Ok();
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 {
15215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15216 }
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15224 PyObject *resultobj = 0;
15225 wxImage *arg1 = (wxImage *) 0 ;
15226 int result;
15227 void *argp1 = 0 ;
15228 int res1 = 0 ;
15229 PyObject *swig_obj[1] ;
15230
15231 if (!args) SWIG_fail;
15232 swig_obj[0] = args;
15233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15234 if (!SWIG_IsOK(res1)) {
15235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15236 }
15237 arg1 = reinterpret_cast< wxImage * >(argp1);
15238 {
15239 PyThreadState* __tstate = wxPyBeginAllowThreads();
15240 result = (int)(arg1)->GetWidth();
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 resultobj = SWIG_From_int(static_cast< int >(result));
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15252 PyObject *resultobj = 0;
15253 wxImage *arg1 = (wxImage *) 0 ;
15254 int result;
15255 void *argp1 = 0 ;
15256 int res1 = 0 ;
15257 PyObject *swig_obj[1] ;
15258
15259 if (!args) SWIG_fail;
15260 swig_obj[0] = args;
15261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15262 if (!SWIG_IsOK(res1)) {
15263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15264 }
15265 arg1 = reinterpret_cast< wxImage * >(argp1);
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 result = (int)(arg1)->GetHeight();
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 resultobj = SWIG_From_int(static_cast< int >(result));
15273 return resultobj;
15274 fail:
15275 return NULL;
15276 }
15277
15278
15279 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15280 PyObject *resultobj = 0;
15281 wxImage *arg1 = (wxImage *) 0 ;
15282 wxSize result;
15283 void *argp1 = 0 ;
15284 int res1 = 0 ;
15285 PyObject *swig_obj[1] ;
15286
15287 if (!args) SWIG_fail;
15288 swig_obj[0] = args;
15289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15290 if (!SWIG_IsOK(res1)) {
15291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15292 }
15293 arg1 = reinterpret_cast< wxImage * >(argp1);
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 result = wxImage_GetSize(arg1);
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15308 PyObject *resultobj = 0;
15309 wxImage *arg1 = (wxImage *) 0 ;
15310 wxRect *arg2 = 0 ;
15311 SwigValueWrapper<wxImage > result;
15312 void *argp1 = 0 ;
15313 int res1 = 0 ;
15314 wxRect temp2 ;
15315 PyObject * obj0 = 0 ;
15316 PyObject * obj1 = 0 ;
15317 char * kwnames[] = {
15318 (char *) "self",(char *) "rect", NULL
15319 };
15320
15321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15323 if (!SWIG_IsOK(res1)) {
15324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15325 }
15326 arg1 = reinterpret_cast< wxImage * >(argp1);
15327 {
15328 arg2 = &temp2;
15329 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15330 }
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15334 wxPyEndAllowThreads(__tstate);
15335 if (PyErr_Occurred()) SWIG_fail;
15336 }
15337 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15338 return resultobj;
15339 fail:
15340 return NULL;
15341 }
15342
15343
15344 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15345 PyObject *resultobj = 0;
15346 wxImage *arg1 = (wxImage *) 0 ;
15347 wxSize *arg2 = 0 ;
15348 wxPoint *arg3 = 0 ;
15349 int arg4 = (int) -1 ;
15350 int arg5 = (int) -1 ;
15351 int arg6 = (int) -1 ;
15352 SwigValueWrapper<wxImage > result;
15353 void *argp1 = 0 ;
15354 int res1 = 0 ;
15355 wxSize temp2 ;
15356 wxPoint temp3 ;
15357 int val4 ;
15358 int ecode4 = 0 ;
15359 int val5 ;
15360 int ecode5 = 0 ;
15361 int val6 ;
15362 int ecode6 = 0 ;
15363 PyObject * obj0 = 0 ;
15364 PyObject * obj1 = 0 ;
15365 PyObject * obj2 = 0 ;
15366 PyObject * obj3 = 0 ;
15367 PyObject * obj4 = 0 ;
15368 PyObject * obj5 = 0 ;
15369 char * kwnames[] = {
15370 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15371 };
15372
15373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15375 if (!SWIG_IsOK(res1)) {
15376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15377 }
15378 arg1 = reinterpret_cast< wxImage * >(argp1);
15379 {
15380 arg2 = &temp2;
15381 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15382 }
15383 {
15384 arg3 = &temp3;
15385 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15386 }
15387 if (obj3) {
15388 ecode4 = SWIG_AsVal_int(obj3, &val4);
15389 if (!SWIG_IsOK(ecode4)) {
15390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15391 }
15392 arg4 = static_cast< int >(val4);
15393 }
15394 if (obj4) {
15395 ecode5 = SWIG_AsVal_int(obj4, &val5);
15396 if (!SWIG_IsOK(ecode5)) {
15397 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15398 }
15399 arg5 = static_cast< int >(val5);
15400 }
15401 if (obj5) {
15402 ecode6 = SWIG_AsVal_int(obj5, &val6);
15403 if (!SWIG_IsOK(ecode6)) {
15404 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15405 }
15406 arg6 = static_cast< int >(val6);
15407 }
15408 {
15409 PyThreadState* __tstate = wxPyBeginAllowThreads();
15410 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15411 wxPyEndAllowThreads(__tstate);
15412 if (PyErr_Occurred()) SWIG_fail;
15413 }
15414 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15422 PyObject *resultobj = 0;
15423 wxImage *arg1 = (wxImage *) 0 ;
15424 SwigValueWrapper<wxImage > result;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 PyObject *swig_obj[1] ;
15428
15429 if (!args) SWIG_fail;
15430 swig_obj[0] = args;
15431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15432 if (!SWIG_IsOK(res1)) {
15433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15434 }
15435 arg1 = reinterpret_cast< wxImage * >(argp1);
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 result = (arg1)->Copy();
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj = 0;
15451 wxImage *arg1 = (wxImage *) 0 ;
15452 wxImage *arg2 = 0 ;
15453 int arg3 ;
15454 int arg4 ;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 void *argp2 = 0 ;
15458 int res2 = 0 ;
15459 int val3 ;
15460 int ecode3 = 0 ;
15461 int val4 ;
15462 int ecode4 = 0 ;
15463 PyObject * obj0 = 0 ;
15464 PyObject * obj1 = 0 ;
15465 PyObject * obj2 = 0 ;
15466 PyObject * obj3 = 0 ;
15467 char * kwnames[] = {
15468 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15469 };
15470
15471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15473 if (!SWIG_IsOK(res1)) {
15474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15475 }
15476 arg1 = reinterpret_cast< wxImage * >(argp1);
15477 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15478 if (!SWIG_IsOK(res2)) {
15479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15480 }
15481 if (!argp2) {
15482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15483 }
15484 arg2 = reinterpret_cast< wxImage * >(argp2);
15485 ecode3 = SWIG_AsVal_int(obj2, &val3);
15486 if (!SWIG_IsOK(ecode3)) {
15487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15488 }
15489 arg3 = static_cast< int >(val3);
15490 ecode4 = SWIG_AsVal_int(obj3, &val4);
15491 if (!SWIG_IsOK(ecode4)) {
15492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15493 }
15494 arg4 = static_cast< int >(val4);
15495 {
15496 PyThreadState* __tstate = wxPyBeginAllowThreads();
15497 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15498 wxPyEndAllowThreads(__tstate);
15499 if (PyErr_Occurred()) SWIG_fail;
15500 }
15501 resultobj = SWIG_Py_Void();
15502 return resultobj;
15503 fail:
15504 return NULL;
15505 }
15506
15507
15508 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15509 PyObject *resultobj = 0;
15510 wxImage *arg1 = (wxImage *) 0 ;
15511 PyObject *result = 0 ;
15512 void *argp1 = 0 ;
15513 int res1 = 0 ;
15514 PyObject *swig_obj[1] ;
15515
15516 if (!args) SWIG_fail;
15517 swig_obj[0] = args;
15518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15521 }
15522 arg1 = reinterpret_cast< wxImage * >(argp1);
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 result = (PyObject *)wxImage_GetData(arg1);
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = result;
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj = 0;
15538 wxImage *arg1 = (wxImage *) 0 ;
15539 buffer arg2 ;
15540 int arg3 ;
15541 void *argp1 = 0 ;
15542 int res1 = 0 ;
15543 Py_ssize_t temp2 ;
15544 PyObject * obj0 = 0 ;
15545 PyObject * obj1 = 0 ;
15546 char * kwnames[] = {
15547 (char *) "self",(char *) "data", NULL
15548 };
15549
15550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15552 if (!SWIG_IsOK(res1)) {
15553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15554 }
15555 arg1 = reinterpret_cast< wxImage * >(argp1);
15556 {
15557 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15558 arg3 = (int)temp2;
15559 }
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 wxImage_SetData(arg1,arg2,arg3);
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_Py_Void();
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15574 PyObject *resultobj = 0;
15575 wxImage *arg1 = (wxImage *) 0 ;
15576 PyObject *result = 0 ;
15577 void *argp1 = 0 ;
15578 int res1 = 0 ;
15579 PyObject *swig_obj[1] ;
15580
15581 if (!args) SWIG_fail;
15582 swig_obj[0] = args;
15583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15584 if (!SWIG_IsOK(res1)) {
15585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15586 }
15587 arg1 = reinterpret_cast< wxImage * >(argp1);
15588 {
15589 PyThreadState* __tstate = wxPyBeginAllowThreads();
15590 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15591 wxPyEndAllowThreads(__tstate);
15592 if (PyErr_Occurred()) SWIG_fail;
15593 }
15594 resultobj = result;
15595 return resultobj;
15596 fail:
15597 return NULL;
15598 }
15599
15600
15601 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15602 PyObject *resultobj = 0;
15603 wxImage *arg1 = (wxImage *) 0 ;
15604 buffer arg2 ;
15605 int arg3 ;
15606 void *argp1 = 0 ;
15607 int res1 = 0 ;
15608 Py_ssize_t temp2 ;
15609 PyObject * obj0 = 0 ;
15610 PyObject * obj1 = 0 ;
15611 char * kwnames[] = {
15612 (char *) "self",(char *) "data", NULL
15613 };
15614
15615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15617 if (!SWIG_IsOK(res1)) {
15618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15619 }
15620 arg1 = reinterpret_cast< wxImage * >(argp1);
15621 {
15622 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15623 arg3 = (int)temp2;
15624 }
15625 {
15626 PyThreadState* __tstate = wxPyBeginAllowThreads();
15627 wxImage_SetDataBuffer(arg1,arg2,arg3);
15628 wxPyEndAllowThreads(__tstate);
15629 if (PyErr_Occurred()) SWIG_fail;
15630 }
15631 resultobj = SWIG_Py_Void();
15632 return resultobj;
15633 fail:
15634 return NULL;
15635 }
15636
15637
15638 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15639 PyObject *resultobj = 0;
15640 wxImage *arg1 = (wxImage *) 0 ;
15641 PyObject *result = 0 ;
15642 void *argp1 = 0 ;
15643 int res1 = 0 ;
15644 PyObject *swig_obj[1] ;
15645
15646 if (!args) SWIG_fail;
15647 swig_obj[0] = args;
15648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15649 if (!SWIG_IsOK(res1)) {
15650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15651 }
15652 arg1 = reinterpret_cast< wxImage * >(argp1);
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 result = (PyObject *)wxImage_GetAlphaData(arg1);
15656 wxPyEndAllowThreads(__tstate);
15657 if (PyErr_Occurred()) SWIG_fail;
15658 }
15659 resultobj = result;
15660 return resultobj;
15661 fail:
15662 return NULL;
15663 }
15664
15665
15666 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15667 PyObject *resultobj = 0;
15668 wxImage *arg1 = (wxImage *) 0 ;
15669 buffer arg2 ;
15670 int arg3 ;
15671 void *argp1 = 0 ;
15672 int res1 = 0 ;
15673 Py_ssize_t temp2 ;
15674 PyObject * obj0 = 0 ;
15675 PyObject * obj1 = 0 ;
15676 char * kwnames[] = {
15677 (char *) "self",(char *) "alpha", NULL
15678 };
15679
15680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15682 if (!SWIG_IsOK(res1)) {
15683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15684 }
15685 arg1 = reinterpret_cast< wxImage * >(argp1);
15686 {
15687 if (obj1 != Py_None) {
15688 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15689 arg3 = (int)temp2;
15690 }
15691 }
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 wxImage_SetAlphaData(arg1,arg2,arg3);
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 resultobj = SWIG_Py_Void();
15699 return resultobj;
15700 fail:
15701 return NULL;
15702 }
15703
15704
15705 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15706 PyObject *resultobj = 0;
15707 wxImage *arg1 = (wxImage *) 0 ;
15708 PyObject *result = 0 ;
15709 void *argp1 = 0 ;
15710 int res1 = 0 ;
15711 PyObject *swig_obj[1] ;
15712
15713 if (!args) SWIG_fail;
15714 swig_obj[0] = args;
15715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15716 if (!SWIG_IsOK(res1)) {
15717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15718 }
15719 arg1 = reinterpret_cast< wxImage * >(argp1);
15720 {
15721 PyThreadState* __tstate = wxPyBeginAllowThreads();
15722 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15723 wxPyEndAllowThreads(__tstate);
15724 if (PyErr_Occurred()) SWIG_fail;
15725 }
15726 resultobj = result;
15727 return resultobj;
15728 fail:
15729 return NULL;
15730 }
15731
15732
15733 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15734 PyObject *resultobj = 0;
15735 wxImage *arg1 = (wxImage *) 0 ;
15736 buffer arg2 ;
15737 int arg3 ;
15738 void *argp1 = 0 ;
15739 int res1 = 0 ;
15740 Py_ssize_t temp2 ;
15741 PyObject * obj0 = 0 ;
15742 PyObject * obj1 = 0 ;
15743 char * kwnames[] = {
15744 (char *) "self",(char *) "alpha", NULL
15745 };
15746
15747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15751 }
15752 arg1 = reinterpret_cast< wxImage * >(argp1);
15753 {
15754 if (obj1 != Py_None) {
15755 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15756 arg3 = (int)temp2;
15757 }
15758 }
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 resultobj = SWIG_Py_Void();
15766 return resultobj;
15767 fail:
15768 return NULL;
15769 }
15770
15771
15772 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15773 PyObject *resultobj = 0;
15774 wxImage *arg1 = (wxImage *) 0 ;
15775 byte arg2 ;
15776 byte arg3 ;
15777 byte arg4 ;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 unsigned char val2 ;
15781 int ecode2 = 0 ;
15782 unsigned char val3 ;
15783 int ecode3 = 0 ;
15784 unsigned char val4 ;
15785 int ecode4 = 0 ;
15786 PyObject * obj0 = 0 ;
15787 PyObject * obj1 = 0 ;
15788 PyObject * obj2 = 0 ;
15789 PyObject * obj3 = 0 ;
15790 char * kwnames[] = {
15791 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15792 };
15793
15794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15796 if (!SWIG_IsOK(res1)) {
15797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15798 }
15799 arg1 = reinterpret_cast< wxImage * >(argp1);
15800 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15801 if (!SWIG_IsOK(ecode2)) {
15802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15803 }
15804 arg2 = static_cast< byte >(val2);
15805 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15806 if (!SWIG_IsOK(ecode3)) {
15807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15808 }
15809 arg3 = static_cast< byte >(val3);
15810 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15811 if (!SWIG_IsOK(ecode4)) {
15812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15813 }
15814 arg4 = static_cast< byte >(val4);
15815 {
15816 PyThreadState* __tstate = wxPyBeginAllowThreads();
15817 (arg1)->SetMaskColour(arg2,arg3,arg4);
15818 wxPyEndAllowThreads(__tstate);
15819 if (PyErr_Occurred()) SWIG_fail;
15820 }
15821 resultobj = SWIG_Py_Void();
15822 return resultobj;
15823 fail:
15824 return NULL;
15825 }
15826
15827
15828 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15829 PyObject *resultobj = 0;
15830 wxImage *arg1 = (wxImage *) 0 ;
15831 byte *arg2 = (byte *) 0 ;
15832 byte *arg3 = (byte *) 0 ;
15833 byte *arg4 = (byte *) 0 ;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 byte temp2 ;
15837 int res2 = SWIG_TMPOBJ ;
15838 byte temp3 ;
15839 int res3 = SWIG_TMPOBJ ;
15840 byte temp4 ;
15841 int res4 = SWIG_TMPOBJ ;
15842 PyObject *swig_obj[1] ;
15843
15844 arg2 = &temp2;
15845 arg3 = &temp3;
15846 arg4 = &temp4;
15847 if (!args) SWIG_fail;
15848 swig_obj[0] = args;
15849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15850 if (!SWIG_IsOK(res1)) {
15851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15852 }
15853 arg1 = reinterpret_cast< wxImage * >(argp1);
15854 {
15855 PyThreadState* __tstate = wxPyBeginAllowThreads();
15856 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 resultobj = SWIG_Py_Void();
15861 if (SWIG_IsTmpObj(res2)) {
15862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15863 } else {
15864 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15866 }
15867 if (SWIG_IsTmpObj(res3)) {
15868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15869 } else {
15870 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15872 }
15873 if (SWIG_IsTmpObj(res4)) {
15874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15875 } else {
15876 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15878 }
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15886 PyObject *resultobj = 0;
15887 wxImage *arg1 = (wxImage *) 0 ;
15888 byte result;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject *swig_obj[1] ;
15892
15893 if (!args) SWIG_fail;
15894 swig_obj[0] = args;
15895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15896 if (!SWIG_IsOK(res1)) {
15897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15898 }
15899 arg1 = reinterpret_cast< wxImage * >(argp1);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (byte)(arg1)->GetMaskRed();
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15914 PyObject *resultobj = 0;
15915 wxImage *arg1 = (wxImage *) 0 ;
15916 byte result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 PyObject *swig_obj[1] ;
15920
15921 if (!args) SWIG_fail;
15922 swig_obj[0] = args;
15923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15924 if (!SWIG_IsOK(res1)) {
15925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15926 }
15927 arg1 = reinterpret_cast< wxImage * >(argp1);
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 result = (byte)(arg1)->GetMaskGreen();
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15935 return resultobj;
15936 fail:
15937 return NULL;
15938 }
15939
15940
15941 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15942 PyObject *resultobj = 0;
15943 wxImage *arg1 = (wxImage *) 0 ;
15944 byte result;
15945 void *argp1 = 0 ;
15946 int res1 = 0 ;
15947 PyObject *swig_obj[1] ;
15948
15949 if (!args) SWIG_fail;
15950 swig_obj[0] = args;
15951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15952 if (!SWIG_IsOK(res1)) {
15953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15954 }
15955 arg1 = reinterpret_cast< wxImage * >(argp1);
15956 {
15957 PyThreadState* __tstate = wxPyBeginAllowThreads();
15958 result = (byte)(arg1)->GetMaskBlue();
15959 wxPyEndAllowThreads(__tstate);
15960 if (PyErr_Occurred()) SWIG_fail;
15961 }
15962 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15970 PyObject *resultobj = 0;
15971 wxImage *arg1 = (wxImage *) 0 ;
15972 bool arg2 = (bool) true ;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 bool val2 ;
15976 int ecode2 = 0 ;
15977 PyObject * obj0 = 0 ;
15978 PyObject * obj1 = 0 ;
15979 char * kwnames[] = {
15980 (char *) "self",(char *) "mask", NULL
15981 };
15982
15983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15985 if (!SWIG_IsOK(res1)) {
15986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15987 }
15988 arg1 = reinterpret_cast< wxImage * >(argp1);
15989 if (obj1) {
15990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15991 if (!SWIG_IsOK(ecode2)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15993 }
15994 arg2 = static_cast< bool >(val2);
15995 }
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 (arg1)->SetMask(arg2);
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_Py_Void();
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16010 PyObject *resultobj = 0;
16011 wxImage *arg1 = (wxImage *) 0 ;
16012 bool result;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 PyObject *swig_obj[1] ;
16016
16017 if (!args) SWIG_fail;
16018 swig_obj[0] = args;
16019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16020 if (!SWIG_IsOK(res1)) {
16021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16022 }
16023 arg1 = reinterpret_cast< wxImage * >(argp1);
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 result = (bool)(arg1)->HasMask();
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 {
16031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16032 }
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16040 PyObject *resultobj = 0;
16041 wxImage *arg1 = (wxImage *) 0 ;
16042 double arg2 ;
16043 wxPoint *arg3 = 0 ;
16044 bool arg4 = (bool) true ;
16045 wxPoint *arg5 = (wxPoint *) NULL ;
16046 SwigValueWrapper<wxImage > result;
16047 void *argp1 = 0 ;
16048 int res1 = 0 ;
16049 double val2 ;
16050 int ecode2 = 0 ;
16051 wxPoint temp3 ;
16052 bool val4 ;
16053 int ecode4 = 0 ;
16054 void *argp5 = 0 ;
16055 int res5 = 0 ;
16056 PyObject * obj0 = 0 ;
16057 PyObject * obj1 = 0 ;
16058 PyObject * obj2 = 0 ;
16059 PyObject * obj3 = 0 ;
16060 PyObject * obj4 = 0 ;
16061 char * kwnames[] = {
16062 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16063 };
16064
16065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16069 }
16070 arg1 = reinterpret_cast< wxImage * >(argp1);
16071 ecode2 = SWIG_AsVal_double(obj1, &val2);
16072 if (!SWIG_IsOK(ecode2)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16074 }
16075 arg2 = static_cast< double >(val2);
16076 {
16077 arg3 = &temp3;
16078 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16079 }
16080 if (obj3) {
16081 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16082 if (!SWIG_IsOK(ecode4)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16084 }
16085 arg4 = static_cast< bool >(val4);
16086 }
16087 if (obj4) {
16088 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16089 if (!SWIG_IsOK(res5)) {
16090 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16091 }
16092 arg5 = reinterpret_cast< wxPoint * >(argp5);
16093 }
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16101 return resultobj;
16102 fail:
16103 return NULL;
16104 }
16105
16106
16107 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16108 PyObject *resultobj = 0;
16109 wxImage *arg1 = (wxImage *) 0 ;
16110 bool arg2 = (bool) true ;
16111 SwigValueWrapper<wxImage > result;
16112 void *argp1 = 0 ;
16113 int res1 = 0 ;
16114 bool val2 ;
16115 int ecode2 = 0 ;
16116 PyObject * obj0 = 0 ;
16117 PyObject * obj1 = 0 ;
16118 char * kwnames[] = {
16119 (char *) "self",(char *) "clockwise", NULL
16120 };
16121
16122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16124 if (!SWIG_IsOK(res1)) {
16125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16126 }
16127 arg1 = reinterpret_cast< wxImage * >(argp1);
16128 if (obj1) {
16129 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16130 if (!SWIG_IsOK(ecode2)) {
16131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16132 }
16133 arg2 = static_cast< bool >(val2);
16134 }
16135 {
16136 PyThreadState* __tstate = wxPyBeginAllowThreads();
16137 result = (arg1)->Rotate90(arg2);
16138 wxPyEndAllowThreads(__tstate);
16139 if (PyErr_Occurred()) SWIG_fail;
16140 }
16141 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16149 PyObject *resultobj = 0;
16150 wxImage *arg1 = (wxImage *) 0 ;
16151 bool arg2 = (bool) true ;
16152 SwigValueWrapper<wxImage > result;
16153 void *argp1 = 0 ;
16154 int res1 = 0 ;
16155 bool val2 ;
16156 int ecode2 = 0 ;
16157 PyObject * obj0 = 0 ;
16158 PyObject * obj1 = 0 ;
16159 char * kwnames[] = {
16160 (char *) "self",(char *) "horizontally", NULL
16161 };
16162
16163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16165 if (!SWIG_IsOK(res1)) {
16166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16167 }
16168 arg1 = reinterpret_cast< wxImage * >(argp1);
16169 if (obj1) {
16170 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16171 if (!SWIG_IsOK(ecode2)) {
16172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16173 }
16174 arg2 = static_cast< bool >(val2);
16175 }
16176 {
16177 PyThreadState* __tstate = wxPyBeginAllowThreads();
16178 result = (arg1)->Mirror(arg2);
16179 wxPyEndAllowThreads(__tstate);
16180 if (PyErr_Occurred()) SWIG_fail;
16181 }
16182 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16183 return resultobj;
16184 fail:
16185 return NULL;
16186 }
16187
16188
16189 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16190 PyObject *resultobj = 0;
16191 wxImage *arg1 = (wxImage *) 0 ;
16192 byte arg2 ;
16193 byte arg3 ;
16194 byte arg4 ;
16195 byte arg5 ;
16196 byte arg6 ;
16197 byte arg7 ;
16198 void *argp1 = 0 ;
16199 int res1 = 0 ;
16200 unsigned char val2 ;
16201 int ecode2 = 0 ;
16202 unsigned char val3 ;
16203 int ecode3 = 0 ;
16204 unsigned char val4 ;
16205 int ecode4 = 0 ;
16206 unsigned char val5 ;
16207 int ecode5 = 0 ;
16208 unsigned char val6 ;
16209 int ecode6 = 0 ;
16210 unsigned char val7 ;
16211 int ecode7 = 0 ;
16212 PyObject * obj0 = 0 ;
16213 PyObject * obj1 = 0 ;
16214 PyObject * obj2 = 0 ;
16215 PyObject * obj3 = 0 ;
16216 PyObject * obj4 = 0 ;
16217 PyObject * obj5 = 0 ;
16218 PyObject * obj6 = 0 ;
16219 char * kwnames[] = {
16220 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16221 };
16222
16223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16227 }
16228 arg1 = reinterpret_cast< wxImage * >(argp1);
16229 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16230 if (!SWIG_IsOK(ecode2)) {
16231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16232 }
16233 arg2 = static_cast< byte >(val2);
16234 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16235 if (!SWIG_IsOK(ecode3)) {
16236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16237 }
16238 arg3 = static_cast< byte >(val3);
16239 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16240 if (!SWIG_IsOK(ecode4)) {
16241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16242 }
16243 arg4 = static_cast< byte >(val4);
16244 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16245 if (!SWIG_IsOK(ecode5)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16247 }
16248 arg5 = static_cast< byte >(val5);
16249 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16250 if (!SWIG_IsOK(ecode6)) {
16251 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16252 }
16253 arg6 = static_cast< byte >(val6);
16254 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16255 if (!SWIG_IsOK(ecode7)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16257 }
16258 arg7 = static_cast< byte >(val7);
16259 {
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 resultobj = SWIG_Py_Void();
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj = 0;
16274 wxImage *arg1 = (wxImage *) 0 ;
16275 double arg2 = (double) 0.299 ;
16276 double arg3 = (double) 0.587 ;
16277 double arg4 = (double) 0.114 ;
16278 SwigValueWrapper<wxImage > result;
16279 void *argp1 = 0 ;
16280 int res1 = 0 ;
16281 double val2 ;
16282 int ecode2 = 0 ;
16283 double val3 ;
16284 int ecode3 = 0 ;
16285 double val4 ;
16286 int ecode4 = 0 ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 PyObject * obj2 = 0 ;
16290 PyObject * obj3 = 0 ;
16291 char * kwnames[] = {
16292 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16293 };
16294
16295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16297 if (!SWIG_IsOK(res1)) {
16298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16299 }
16300 arg1 = reinterpret_cast< wxImage * >(argp1);
16301 if (obj1) {
16302 ecode2 = SWIG_AsVal_double(obj1, &val2);
16303 if (!SWIG_IsOK(ecode2)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16305 }
16306 arg2 = static_cast< double >(val2);
16307 }
16308 if (obj2) {
16309 ecode3 = SWIG_AsVal_double(obj2, &val3);
16310 if (!SWIG_IsOK(ecode3)) {
16311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16312 }
16313 arg3 = static_cast< double >(val3);
16314 }
16315 if (obj3) {
16316 ecode4 = SWIG_AsVal_double(obj3, &val4);
16317 if (!SWIG_IsOK(ecode4)) {
16318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16319 }
16320 arg4 = static_cast< double >(val4);
16321 }
16322 {
16323 PyThreadState* __tstate = wxPyBeginAllowThreads();
16324 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16329 return resultobj;
16330 fail:
16331 return NULL;
16332 }
16333
16334
16335 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16336 PyObject *resultobj = 0;
16337 wxImage *arg1 = (wxImage *) 0 ;
16338 byte arg2 ;
16339 byte arg3 ;
16340 byte arg4 ;
16341 SwigValueWrapper<wxImage > result;
16342 void *argp1 = 0 ;
16343 int res1 = 0 ;
16344 unsigned char val2 ;
16345 int ecode2 = 0 ;
16346 unsigned char val3 ;
16347 int ecode3 = 0 ;
16348 unsigned char val4 ;
16349 int ecode4 = 0 ;
16350 PyObject * obj0 = 0 ;
16351 PyObject * obj1 = 0 ;
16352 PyObject * obj2 = 0 ;
16353 PyObject * obj3 = 0 ;
16354 char * kwnames[] = {
16355 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16356 };
16357
16358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16360 if (!SWIG_IsOK(res1)) {
16361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16362 }
16363 arg1 = reinterpret_cast< wxImage * >(argp1);
16364 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16365 if (!SWIG_IsOK(ecode2)) {
16366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16367 }
16368 arg2 = static_cast< byte >(val2);
16369 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16370 if (!SWIG_IsOK(ecode3)) {
16371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16372 }
16373 arg3 = static_cast< byte >(val3);
16374 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16375 if (!SWIG_IsOK(ecode4)) {
16376 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16377 }
16378 arg4 = static_cast< byte >(val4);
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16386 return resultobj;
16387 fail:
16388 return NULL;
16389 }
16390
16391
16392 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16393 PyObject *resultobj = 0;
16394 wxImage *arg1 = (wxImage *) 0 ;
16395 wxString *arg2 = 0 ;
16396 wxString *arg3 = 0 ;
16397 void *argp1 = 0 ;
16398 int res1 = 0 ;
16399 bool temp2 = false ;
16400 bool temp3 = false ;
16401 PyObject * obj0 = 0 ;
16402 PyObject * obj1 = 0 ;
16403 PyObject * obj2 = 0 ;
16404 char * kwnames[] = {
16405 (char *) "self",(char *) "name",(char *) "value", NULL
16406 };
16407
16408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16410 if (!SWIG_IsOK(res1)) {
16411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16412 }
16413 arg1 = reinterpret_cast< wxImage * >(argp1);
16414 {
16415 arg2 = wxString_in_helper(obj1);
16416 if (arg2 == NULL) SWIG_fail;
16417 temp2 = true;
16418 }
16419 {
16420 arg3 = wxString_in_helper(obj2);
16421 if (arg3 == NULL) SWIG_fail;
16422 temp3 = true;
16423 }
16424 {
16425 PyThreadState* __tstate = wxPyBeginAllowThreads();
16426 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16427 wxPyEndAllowThreads(__tstate);
16428 if (PyErr_Occurred()) SWIG_fail;
16429 }
16430 resultobj = SWIG_Py_Void();
16431 {
16432 if (temp2)
16433 delete arg2;
16434 }
16435 {
16436 if (temp3)
16437 delete arg3;
16438 }
16439 return resultobj;
16440 fail:
16441 {
16442 if (temp2)
16443 delete arg2;
16444 }
16445 {
16446 if (temp3)
16447 delete arg3;
16448 }
16449 return NULL;
16450 }
16451
16452
16453 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj = 0;
16455 wxImage *arg1 = (wxImage *) 0 ;
16456 wxString *arg2 = 0 ;
16457 int arg3 ;
16458 void *argp1 = 0 ;
16459 int res1 = 0 ;
16460 bool temp2 = false ;
16461 int val3 ;
16462 int ecode3 = 0 ;
16463 PyObject * obj0 = 0 ;
16464 PyObject * obj1 = 0 ;
16465 PyObject * obj2 = 0 ;
16466 char * kwnames[] = {
16467 (char *) "self",(char *) "name",(char *) "value", NULL
16468 };
16469
16470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16472 if (!SWIG_IsOK(res1)) {
16473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16474 }
16475 arg1 = reinterpret_cast< wxImage * >(argp1);
16476 {
16477 arg2 = wxString_in_helper(obj1);
16478 if (arg2 == NULL) SWIG_fail;
16479 temp2 = true;
16480 }
16481 ecode3 = SWIG_AsVal_int(obj2, &val3);
16482 if (!SWIG_IsOK(ecode3)) {
16483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16484 }
16485 arg3 = static_cast< int >(val3);
16486 {
16487 PyThreadState* __tstate = wxPyBeginAllowThreads();
16488 (arg1)->SetOption((wxString const &)*arg2,arg3);
16489 wxPyEndAllowThreads(__tstate);
16490 if (PyErr_Occurred()) SWIG_fail;
16491 }
16492 resultobj = SWIG_Py_Void();
16493 {
16494 if (temp2)
16495 delete arg2;
16496 }
16497 return resultobj;
16498 fail:
16499 {
16500 if (temp2)
16501 delete arg2;
16502 }
16503 return NULL;
16504 }
16505
16506
16507 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16508 PyObject *resultobj = 0;
16509 wxImage *arg1 = (wxImage *) 0 ;
16510 wxString *arg2 = 0 ;
16511 wxString result;
16512 void *argp1 = 0 ;
16513 int res1 = 0 ;
16514 bool temp2 = false ;
16515 PyObject * obj0 = 0 ;
16516 PyObject * obj1 = 0 ;
16517 char * kwnames[] = {
16518 (char *) "self",(char *) "name", NULL
16519 };
16520
16521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16523 if (!SWIG_IsOK(res1)) {
16524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16525 }
16526 arg1 = reinterpret_cast< wxImage * >(argp1);
16527 {
16528 arg2 = wxString_in_helper(obj1);
16529 if (arg2 == NULL) SWIG_fail;
16530 temp2 = true;
16531 }
16532 {
16533 PyThreadState* __tstate = wxPyBeginAllowThreads();
16534 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 {
16539 #if wxUSE_UNICODE
16540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16541 #else
16542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16543 #endif
16544 }
16545 {
16546 if (temp2)
16547 delete arg2;
16548 }
16549 return resultobj;
16550 fail:
16551 {
16552 if (temp2)
16553 delete arg2;
16554 }
16555 return NULL;
16556 }
16557
16558
16559 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16560 PyObject *resultobj = 0;
16561 wxImage *arg1 = (wxImage *) 0 ;
16562 wxString *arg2 = 0 ;
16563 int result;
16564 void *argp1 = 0 ;
16565 int res1 = 0 ;
16566 bool temp2 = false ;
16567 PyObject * obj0 = 0 ;
16568 PyObject * obj1 = 0 ;
16569 char * kwnames[] = {
16570 (char *) "self",(char *) "name", NULL
16571 };
16572
16573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16575 if (!SWIG_IsOK(res1)) {
16576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16577 }
16578 arg1 = reinterpret_cast< wxImage * >(argp1);
16579 {
16580 arg2 = wxString_in_helper(obj1);
16581 if (arg2 == NULL) SWIG_fail;
16582 temp2 = true;
16583 }
16584 {
16585 PyThreadState* __tstate = wxPyBeginAllowThreads();
16586 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 resultobj = SWIG_From_int(static_cast< int >(result));
16591 {
16592 if (temp2)
16593 delete arg2;
16594 }
16595 return resultobj;
16596 fail:
16597 {
16598 if (temp2)
16599 delete arg2;
16600 }
16601 return NULL;
16602 }
16603
16604
16605 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16606 PyObject *resultobj = 0;
16607 wxImage *arg1 = (wxImage *) 0 ;
16608 wxString *arg2 = 0 ;
16609 bool result;
16610 void *argp1 = 0 ;
16611 int res1 = 0 ;
16612 bool temp2 = false ;
16613 PyObject * obj0 = 0 ;
16614 PyObject * obj1 = 0 ;
16615 char * kwnames[] = {
16616 (char *) "self",(char *) "name", NULL
16617 };
16618
16619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16621 if (!SWIG_IsOK(res1)) {
16622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16623 }
16624 arg1 = reinterpret_cast< wxImage * >(argp1);
16625 {
16626 arg2 = wxString_in_helper(obj1);
16627 if (arg2 == NULL) SWIG_fail;
16628 temp2 = true;
16629 }
16630 {
16631 PyThreadState* __tstate = wxPyBeginAllowThreads();
16632 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 {
16637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16638 }
16639 {
16640 if (temp2)
16641 delete arg2;
16642 }
16643 return resultobj;
16644 fail:
16645 {
16646 if (temp2)
16647 delete arg2;
16648 }
16649 return NULL;
16650 }
16651
16652
16653 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16654 PyObject *resultobj = 0;
16655 wxImage *arg1 = (wxImage *) 0 ;
16656 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16657 unsigned long result;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 unsigned long val2 ;
16661 int ecode2 = 0 ;
16662 PyObject * obj0 = 0 ;
16663 PyObject * obj1 = 0 ;
16664 char * kwnames[] = {
16665 (char *) "self",(char *) "stopafter", NULL
16666 };
16667
16668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16670 if (!SWIG_IsOK(res1)) {
16671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16672 }
16673 arg1 = reinterpret_cast< wxImage * >(argp1);
16674 if (obj1) {
16675 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16676 if (!SWIG_IsOK(ecode2)) {
16677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16678 }
16679 arg2 = static_cast< unsigned long >(val2);
16680 }
16681 {
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = (unsigned long)(arg1)->CountColours(arg2);
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16695 PyObject *resultobj = 0;
16696 wxImage *arg1 = (wxImage *) 0 ;
16697 wxImageHistogram *arg2 = 0 ;
16698 unsigned long result;
16699 void *argp1 = 0 ;
16700 int res1 = 0 ;
16701 void *argp2 = 0 ;
16702 int res2 = 0 ;
16703 PyObject * obj0 = 0 ;
16704 PyObject * obj1 = 0 ;
16705 char * kwnames[] = {
16706 (char *) "self",(char *) "h", NULL
16707 };
16708
16709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16711 if (!SWIG_IsOK(res1)) {
16712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16713 }
16714 arg1 = reinterpret_cast< wxImage * >(argp1);
16715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16716 if (!SWIG_IsOK(res2)) {
16717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16718 }
16719 if (!argp2) {
16720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16721 }
16722 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16723 {
16724 PyThreadState* __tstate = wxPyBeginAllowThreads();
16725 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16726 wxPyEndAllowThreads(__tstate);
16727 if (PyErr_Occurred()) SWIG_fail;
16728 }
16729 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16730 return resultobj;
16731 fail:
16732 return NULL;
16733 }
16734
16735
16736 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16737 PyObject *resultobj = 0;
16738 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16739 void *argp1 = 0 ;
16740 int res1 = 0 ;
16741 PyObject * obj0 = 0 ;
16742 char * kwnames[] = {
16743 (char *) "handler", NULL
16744 };
16745
16746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16748 if (!SWIG_IsOK(res1)) {
16749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16750 }
16751 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 wxImage::AddHandler(arg1);
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 resultobj = SWIG_Py_Void();
16759 return resultobj;
16760 fail:
16761 return NULL;
16762 }
16763
16764
16765 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16766 PyObject *resultobj = 0;
16767 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16768 void *argp1 = 0 ;
16769 int res1 = 0 ;
16770 PyObject * obj0 = 0 ;
16771 char * kwnames[] = {
16772 (char *) "handler", NULL
16773 };
16774
16775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16777 if (!SWIG_IsOK(res1)) {
16778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16779 }
16780 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16781 {
16782 PyThreadState* __tstate = wxPyBeginAllowThreads();
16783 wxImage::InsertHandler(arg1);
16784 wxPyEndAllowThreads(__tstate);
16785 if (PyErr_Occurred()) SWIG_fail;
16786 }
16787 resultobj = SWIG_Py_Void();
16788 return resultobj;
16789 fail:
16790 return NULL;
16791 }
16792
16793
16794 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16795 PyObject *resultobj = 0;
16796 wxString *arg1 = 0 ;
16797 bool result;
16798 bool temp1 = false ;
16799 PyObject * obj0 = 0 ;
16800 char * kwnames[] = {
16801 (char *) "name", NULL
16802 };
16803
16804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16805 {
16806 arg1 = wxString_in_helper(obj0);
16807 if (arg1 == NULL) SWIG_fail;
16808 temp1 = true;
16809 }
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16813 wxPyEndAllowThreads(__tstate);
16814 if (PyErr_Occurred()) SWIG_fail;
16815 }
16816 {
16817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16818 }
16819 {
16820 if (temp1)
16821 delete arg1;
16822 }
16823 return resultobj;
16824 fail:
16825 {
16826 if (temp1)
16827 delete arg1;
16828 }
16829 return NULL;
16830 }
16831
16832
16833 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16834 PyObject *resultobj = 0;
16835 PyObject *result = 0 ;
16836
16837 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 result = (PyObject *)wxImage_GetHandlers();
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = result;
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16852 PyObject *resultobj = 0;
16853 wxString result;
16854
16855 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16856 {
16857 PyThreadState* __tstate = wxPyBeginAllowThreads();
16858 result = wxImage::GetImageExtWildcard();
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 {
16863 #if wxUSE_UNICODE
16864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16865 #else
16866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16867 #endif
16868 }
16869 return resultobj;
16870 fail:
16871 return NULL;
16872 }
16873
16874
16875 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16876 PyObject *resultobj = 0;
16877 wxImage *arg1 = (wxImage *) 0 ;
16878 int arg2 = (int) -1 ;
16879 wxBitmap result;
16880 void *argp1 = 0 ;
16881 int res1 = 0 ;
16882 int val2 ;
16883 int ecode2 = 0 ;
16884 PyObject * obj0 = 0 ;
16885 PyObject * obj1 = 0 ;
16886 char * kwnames[] = {
16887 (char *) "self",(char *) "depth", NULL
16888 };
16889
16890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16892 if (!SWIG_IsOK(res1)) {
16893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16894 }
16895 arg1 = reinterpret_cast< wxImage * >(argp1);
16896 if (obj1) {
16897 ecode2 = SWIG_AsVal_int(obj1, &val2);
16898 if (!SWIG_IsOK(ecode2)) {
16899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16900 }
16901 arg2 = static_cast< int >(val2);
16902 }
16903 {
16904 if (!wxPyCheckForApp()) SWIG_fail;
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = wxImage_ConvertToBitmap(arg1,arg2);
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj = 0;
16919 wxImage *arg1 = (wxImage *) 0 ;
16920 byte arg2 ;
16921 byte arg3 ;
16922 byte arg4 ;
16923 wxBitmap result;
16924 void *argp1 = 0 ;
16925 int res1 = 0 ;
16926 unsigned char val2 ;
16927 int ecode2 = 0 ;
16928 unsigned char val3 ;
16929 int ecode3 = 0 ;
16930 unsigned char val4 ;
16931 int ecode4 = 0 ;
16932 PyObject * obj0 = 0 ;
16933 PyObject * obj1 = 0 ;
16934 PyObject * obj2 = 0 ;
16935 PyObject * obj3 = 0 ;
16936 char * kwnames[] = {
16937 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16938 };
16939
16940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16942 if (!SWIG_IsOK(res1)) {
16943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16944 }
16945 arg1 = reinterpret_cast< wxImage * >(argp1);
16946 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16947 if (!SWIG_IsOK(ecode2)) {
16948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16949 }
16950 arg2 = static_cast< byte >(val2);
16951 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16952 if (!SWIG_IsOK(ecode3)) {
16953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16954 }
16955 arg3 = static_cast< byte >(val3);
16956 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16957 if (!SWIG_IsOK(ecode4)) {
16958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16959 }
16960 arg4 = static_cast< byte >(val4);
16961 {
16962 if (!wxPyCheckForApp()) SWIG_fail;
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16969 return resultobj;
16970 fail:
16971 return NULL;
16972 }
16973
16974
16975 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16976 PyObject *resultobj = 0;
16977 wxImage *arg1 = (wxImage *) 0 ;
16978 double arg2 ;
16979 void *argp1 = 0 ;
16980 int res1 = 0 ;
16981 double val2 ;
16982 int ecode2 = 0 ;
16983 PyObject * obj0 = 0 ;
16984 PyObject * obj1 = 0 ;
16985 char * kwnames[] = {
16986 (char *) "self",(char *) "angle", NULL
16987 };
16988
16989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16991 if (!SWIG_IsOK(res1)) {
16992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16993 }
16994 arg1 = reinterpret_cast< wxImage * >(argp1);
16995 ecode2 = SWIG_AsVal_double(obj1, &val2);
16996 if (!SWIG_IsOK(ecode2)) {
16997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16998 }
16999 arg2 = static_cast< double >(val2);
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 (arg1)->RotateHue(arg2);
17003 wxPyEndAllowThreads(__tstate);
17004 if (PyErr_Occurred()) SWIG_fail;
17005 }
17006 resultobj = SWIG_Py_Void();
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj = 0;
17015 wxImage_RGBValue arg1 ;
17016 wxImage_HSVValue result;
17017 void *argp1 ;
17018 int res1 = 0 ;
17019 PyObject * obj0 = 0 ;
17020 char * kwnames[] = {
17021 (char *) "rgb", NULL
17022 };
17023
17024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17025 {
17026 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17027 if (!SWIG_IsOK(res1)) {
17028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17029 }
17030 if (!argp1) {
17031 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17032 } else {
17033 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17034 arg1 = *temp;
17035 if (SWIG_IsNewObj(res1)) delete temp;
17036 }
17037 }
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 result = wxImage::RGBtoHSV(arg1);
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj = 0;
17053 wxImage_HSVValue arg1 ;
17054 wxImage_RGBValue result;
17055 void *argp1 ;
17056 int res1 = 0 ;
17057 PyObject * obj0 = 0 ;
17058 char * kwnames[] = {
17059 (char *) "hsv", NULL
17060 };
17061
17062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17063 {
17064 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17065 if (!SWIG_IsOK(res1)) {
17066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17067 }
17068 if (!argp1) {
17069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17070 } else {
17071 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17072 arg1 = *temp;
17073 if (SWIG_IsNewObj(res1)) delete temp;
17074 }
17075 }
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = wxImage::HSVtoRGB(arg1);
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17090 PyObject *obj;
17091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17092 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17093 return SWIG_Py_Void();
17094 }
17095
17096 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17097 return SWIG_Python_InitShadowInstance(args);
17098 }
17099
17100 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17101 PyObject *resultobj = 0;
17102 int arg1 ;
17103 int arg2 ;
17104 buffer arg3 ;
17105 int arg4 ;
17106 buffer arg5 = (buffer) NULL ;
17107 int arg6 = (int) 0 ;
17108 wxImage *result = 0 ;
17109 int val1 ;
17110 int ecode1 = 0 ;
17111 int val2 ;
17112 int ecode2 = 0 ;
17113 Py_ssize_t temp3 ;
17114 Py_ssize_t temp5 ;
17115 PyObject * obj0 = 0 ;
17116 PyObject * obj1 = 0 ;
17117 PyObject * obj2 = 0 ;
17118 PyObject * obj3 = 0 ;
17119 char * kwnames[] = {
17120 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17121 };
17122
17123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17124 ecode1 = SWIG_AsVal_int(obj0, &val1);
17125 if (!SWIG_IsOK(ecode1)) {
17126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17127 }
17128 arg1 = static_cast< int >(val1);
17129 ecode2 = SWIG_AsVal_int(obj1, &val2);
17130 if (!SWIG_IsOK(ecode2)) {
17131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17132 }
17133 arg2 = static_cast< int >(val2);
17134 {
17135 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17136 arg4 = (int)temp3;
17137 }
17138 if (obj3) {
17139 {
17140 if (obj3 != Py_None) {
17141 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17142 arg6 = (int)temp5;
17143 }
17144 }
17145 }
17146 {
17147 PyThreadState* __tstate = wxPyBeginAllowThreads();
17148 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17149 wxPyEndAllowThreads(__tstate);
17150 if (PyErr_Occurred()) SWIG_fail;
17151 }
17152 {
17153 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17154 }
17155 return resultobj;
17156 fail:
17157 return NULL;
17158 }
17159
17160
17161 SWIGINTERN int NullImage_set(PyObject *) {
17162 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17163 return 1;
17164 }
17165
17166
17167 SWIGINTERN PyObject *NullImage_get(void) {
17168 PyObject *pyobj = 0;
17169
17170 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17171 return pyobj;
17172 }
17173
17174
17175 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17176 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17177 return 1;
17178 }
17179
17180
17181 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17182 PyObject *pyobj = 0;
17183
17184 {
17185 #if wxUSE_UNICODE
17186 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17187 #else
17188 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17189 #endif
17190 }
17191 return pyobj;
17192 }
17193
17194
17195 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17196 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17197 return 1;
17198 }
17199
17200
17201 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17202 PyObject *pyobj = 0;
17203
17204 {
17205 #if wxUSE_UNICODE
17206 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17207 #else
17208 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17209 #endif
17210 }
17211 return pyobj;
17212 }
17213
17214
17215 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17216 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17217 return 1;
17218 }
17219
17220
17221 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17222 PyObject *pyobj = 0;
17223
17224 {
17225 #if wxUSE_UNICODE
17226 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17227 #else
17228 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17229 #endif
17230 }
17231 return pyobj;
17232 }
17233
17234
17235 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17236 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17237 return 1;
17238 }
17239
17240
17241 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17242 PyObject *pyobj = 0;
17243
17244 {
17245 #if wxUSE_UNICODE
17246 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17247 #else
17248 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17249 #endif
17250 }
17251 return pyobj;
17252 }
17253
17254
17255 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17256 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17257 return 1;
17258 }
17259
17260
17261 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17262 PyObject *pyobj = 0;
17263
17264 {
17265 #if wxUSE_UNICODE
17266 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17267 #else
17268 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17269 #endif
17270 }
17271 return pyobj;
17272 }
17273
17274
17275 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17276 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17277 return 1;
17278 }
17279
17280
17281 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17282 PyObject *pyobj = 0;
17283
17284 {
17285 #if wxUSE_UNICODE
17286 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17287 #else
17288 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17289 #endif
17290 }
17291 return pyobj;
17292 }
17293
17294
17295 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17296 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17297 return 1;
17298 }
17299
17300
17301 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17302 PyObject *pyobj = 0;
17303
17304 {
17305 #if wxUSE_UNICODE
17306 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17307 #else
17308 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17309 #endif
17310 }
17311 return pyobj;
17312 }
17313
17314
17315 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17316 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17317 return 1;
17318 }
17319
17320
17321 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17322 PyObject *pyobj = 0;
17323
17324 {
17325 #if wxUSE_UNICODE
17326 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17327 #else
17328 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17329 #endif
17330 }
17331 return pyobj;
17332 }
17333
17334
17335 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17336 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17337 return 1;
17338 }
17339
17340
17341 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17342 PyObject *pyobj = 0;
17343
17344 {
17345 #if wxUSE_UNICODE
17346 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17347 #else
17348 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17349 #endif
17350 }
17351 return pyobj;
17352 }
17353
17354
17355 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17356 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17357 return 1;
17358 }
17359
17360
17361 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17362 PyObject *pyobj = 0;
17363
17364 {
17365 #if wxUSE_UNICODE
17366 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17367 #else
17368 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17369 #endif
17370 }
17371 return pyobj;
17372 }
17373
17374
17375 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17376 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17377 return 1;
17378 }
17379
17380
17381 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17382 PyObject *pyobj = 0;
17383
17384 {
17385 #if wxUSE_UNICODE
17386 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17387 #else
17388 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17389 #endif
17390 }
17391 return pyobj;
17392 }
17393
17394
17395 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17396 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17397 return 1;
17398 }
17399
17400
17401 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17402 PyObject *pyobj = 0;
17403
17404 {
17405 #if wxUSE_UNICODE
17406 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17407 #else
17408 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17409 #endif
17410 }
17411 return pyobj;
17412 }
17413
17414
17415 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17416 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17417 return 1;
17418 }
17419
17420
17421 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17422 PyObject *pyobj = 0;
17423
17424 {
17425 #if wxUSE_UNICODE
17426 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17427 #else
17428 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17429 #endif
17430 }
17431 return pyobj;
17432 }
17433
17434
17435 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17436 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17437 return 1;
17438 }
17439
17440
17441 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17442 PyObject *pyobj = 0;
17443
17444 {
17445 #if wxUSE_UNICODE
17446 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17447 #else
17448 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17449 #endif
17450 }
17451 return pyobj;
17452 }
17453
17454
17455 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17456 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17457 return 1;
17458 }
17459
17460
17461 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17462 PyObject *pyobj = 0;
17463
17464 {
17465 #if wxUSE_UNICODE
17466 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17467 #else
17468 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17469 #endif
17470 }
17471 return pyobj;
17472 }
17473
17474
17475 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 PyObject *resultobj = 0;
17477 wxBMPHandler *result = 0 ;
17478
17479 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (wxBMPHandler *)new wxBMPHandler();
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17487 return resultobj;
17488 fail:
17489 return NULL;
17490 }
17491
17492
17493 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17494 PyObject *obj;
17495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17496 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17497 return SWIG_Py_Void();
17498 }
17499
17500 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17501 return SWIG_Python_InitShadowInstance(args);
17502 }
17503
17504 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17505 PyObject *resultobj = 0;
17506 wxICOHandler *result = 0 ;
17507
17508 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = (wxICOHandler *)new wxICOHandler();
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17523 PyObject *obj;
17524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17525 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17526 return SWIG_Py_Void();
17527 }
17528
17529 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17530 return SWIG_Python_InitShadowInstance(args);
17531 }
17532
17533 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17534 PyObject *resultobj = 0;
17535 wxCURHandler *result = 0 ;
17536
17537 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (wxCURHandler *)new wxCURHandler();
17541 wxPyEndAllowThreads(__tstate);
17542 if (PyErr_Occurred()) SWIG_fail;
17543 }
17544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17545 return resultobj;
17546 fail:
17547 return NULL;
17548 }
17549
17550
17551 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17552 PyObject *obj;
17553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17554 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17555 return SWIG_Py_Void();
17556 }
17557
17558 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17559 return SWIG_Python_InitShadowInstance(args);
17560 }
17561
17562 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17563 PyObject *resultobj = 0;
17564 wxANIHandler *result = 0 ;
17565
17566 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17567 {
17568 PyThreadState* __tstate = wxPyBeginAllowThreads();
17569 result = (wxANIHandler *)new wxANIHandler();
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17574 return resultobj;
17575 fail:
17576 return NULL;
17577 }
17578
17579
17580 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 PyObject *obj;
17582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17583 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17584 return SWIG_Py_Void();
17585 }
17586
17587 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17588 return SWIG_Python_InitShadowInstance(args);
17589 }
17590
17591 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17592 PyObject *resultobj = 0;
17593 wxPNGHandler *result = 0 ;
17594
17595 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17596 {
17597 PyThreadState* __tstate = wxPyBeginAllowThreads();
17598 result = (wxPNGHandler *)new wxPNGHandler();
17599 wxPyEndAllowThreads(__tstate);
17600 if (PyErr_Occurred()) SWIG_fail;
17601 }
17602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17610 PyObject *obj;
17611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17612 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17613 return SWIG_Py_Void();
17614 }
17615
17616 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17617 return SWIG_Python_InitShadowInstance(args);
17618 }
17619
17620 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621 PyObject *resultobj = 0;
17622 wxGIFHandler *result = 0 ;
17623
17624 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17625 {
17626 PyThreadState* __tstate = wxPyBeginAllowThreads();
17627 result = (wxGIFHandler *)new wxGIFHandler();
17628 wxPyEndAllowThreads(__tstate);
17629 if (PyErr_Occurred()) SWIG_fail;
17630 }
17631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17639 PyObject *obj;
17640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17641 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17642 return SWIG_Py_Void();
17643 }
17644
17645 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17646 return SWIG_Python_InitShadowInstance(args);
17647 }
17648
17649 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17650 PyObject *resultobj = 0;
17651 wxPCXHandler *result = 0 ;
17652
17653 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17654 {
17655 PyThreadState* __tstate = wxPyBeginAllowThreads();
17656 result = (wxPCXHandler *)new wxPCXHandler();
17657 wxPyEndAllowThreads(__tstate);
17658 if (PyErr_Occurred()) SWIG_fail;
17659 }
17660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17668 PyObject *obj;
17669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17670 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17671 return SWIG_Py_Void();
17672 }
17673
17674 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17675 return SWIG_Python_InitShadowInstance(args);
17676 }
17677
17678 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17679 PyObject *resultobj = 0;
17680 wxJPEGHandler *result = 0 ;
17681
17682 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = (wxJPEGHandler *)new wxJPEGHandler();
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17690 return resultobj;
17691 fail:
17692 return NULL;
17693 }
17694
17695
17696 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17697 PyObject *obj;
17698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17699 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17700 return SWIG_Py_Void();
17701 }
17702
17703 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17704 return SWIG_Python_InitShadowInstance(args);
17705 }
17706
17707 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17708 PyObject *resultobj = 0;
17709 wxPNMHandler *result = 0 ;
17710
17711 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17712 {
17713 PyThreadState* __tstate = wxPyBeginAllowThreads();
17714 result = (wxPNMHandler *)new wxPNMHandler();
17715 wxPyEndAllowThreads(__tstate);
17716 if (PyErr_Occurred()) SWIG_fail;
17717 }
17718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17719 return resultobj;
17720 fail:
17721 return NULL;
17722 }
17723
17724
17725 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17726 PyObject *obj;
17727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17728 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17729 return SWIG_Py_Void();
17730 }
17731
17732 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17733 return SWIG_Python_InitShadowInstance(args);
17734 }
17735
17736 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17737 PyObject *resultobj = 0;
17738 wxXPMHandler *result = 0 ;
17739
17740 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17741 {
17742 PyThreadState* __tstate = wxPyBeginAllowThreads();
17743 result = (wxXPMHandler *)new wxXPMHandler();
17744 wxPyEndAllowThreads(__tstate);
17745 if (PyErr_Occurred()) SWIG_fail;
17746 }
17747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17748 return resultobj;
17749 fail:
17750 return NULL;
17751 }
17752
17753
17754 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17755 PyObject *obj;
17756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17757 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17758 return SWIG_Py_Void();
17759 }
17760
17761 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17762 return SWIG_Python_InitShadowInstance(args);
17763 }
17764
17765 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17766 PyObject *resultobj = 0;
17767 wxTIFFHandler *result = 0 ;
17768
17769 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17770 {
17771 PyThreadState* __tstate = wxPyBeginAllowThreads();
17772 result = (wxTIFFHandler *)new wxTIFFHandler();
17773 wxPyEndAllowThreads(__tstate);
17774 if (PyErr_Occurred()) SWIG_fail;
17775 }
17776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17777 return resultobj;
17778 fail:
17779 return NULL;
17780 }
17781
17782
17783 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17784 PyObject *obj;
17785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17786 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17787 return SWIG_Py_Void();
17788 }
17789
17790 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791 return SWIG_Python_InitShadowInstance(args);
17792 }
17793
17794 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17795 PyObject *resultobj = 0;
17796 wxImage *arg1 = 0 ;
17797 wxImage *arg2 = 0 ;
17798 int arg3 = (int) 236 ;
17799 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17800 bool result;
17801 void *argp1 = 0 ;
17802 int res1 = 0 ;
17803 void *argp2 = 0 ;
17804 int res2 = 0 ;
17805 int val3 ;
17806 int ecode3 = 0 ;
17807 int val4 ;
17808 int ecode4 = 0 ;
17809 PyObject * obj0 = 0 ;
17810 PyObject * obj1 = 0 ;
17811 PyObject * obj2 = 0 ;
17812 PyObject * obj3 = 0 ;
17813 char * kwnames[] = {
17814 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17815 };
17816
17817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17818 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17819 if (!SWIG_IsOK(res1)) {
17820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17821 }
17822 if (!argp1) {
17823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17824 }
17825 arg1 = reinterpret_cast< wxImage * >(argp1);
17826 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17827 if (!SWIG_IsOK(res2)) {
17828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17829 }
17830 if (!argp2) {
17831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17832 }
17833 arg2 = reinterpret_cast< wxImage * >(argp2);
17834 if (obj2) {
17835 ecode3 = SWIG_AsVal_int(obj2, &val3);
17836 if (!SWIG_IsOK(ecode3)) {
17837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17838 }
17839 arg3 = static_cast< int >(val3);
17840 }
17841 if (obj3) {
17842 ecode4 = SWIG_AsVal_int(obj3, &val4);
17843 if (!SWIG_IsOK(ecode4)) {
17844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17845 }
17846 arg4 = static_cast< int >(val4);
17847 }
17848 {
17849 PyThreadState* __tstate = wxPyBeginAllowThreads();
17850 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17851 wxPyEndAllowThreads(__tstate);
17852 if (PyErr_Occurred()) SWIG_fail;
17853 }
17854 {
17855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17856 }
17857 return resultobj;
17858 fail:
17859 return NULL;
17860 }
17861
17862
17863 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17864 PyObject *obj;
17865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17866 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17867 return SWIG_Py_Void();
17868 }
17869
17870 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17871 PyObject *resultobj = 0;
17872 wxEvtHandler *result = 0 ;
17873
17874 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17875 {
17876 PyThreadState* __tstate = wxPyBeginAllowThreads();
17877 result = (wxEvtHandler *)new wxEvtHandler();
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17889 PyObject *resultobj = 0;
17890 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17891 wxEvtHandler *result = 0 ;
17892 void *argp1 = 0 ;
17893 int res1 = 0 ;
17894 PyObject *swig_obj[1] ;
17895
17896 if (!args) SWIG_fail;
17897 swig_obj[0] = args;
17898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17899 if (!SWIG_IsOK(res1)) {
17900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17901 }
17902 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17903 {
17904 PyThreadState* __tstate = wxPyBeginAllowThreads();
17905 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17906 wxPyEndAllowThreads(__tstate);
17907 if (PyErr_Occurred()) SWIG_fail;
17908 }
17909 {
17910 resultobj = wxPyMake_wxObject(result, 0);
17911 }
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17919 PyObject *resultobj = 0;
17920 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17921 wxEvtHandler *result = 0 ;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 PyObject *swig_obj[1] ;
17925
17926 if (!args) SWIG_fail;
17927 swig_obj[0] = args;
17928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17931 }
17932 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 resultobj = wxPyMake_wxObject(result, 0);
17941 }
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17949 PyObject *resultobj = 0;
17950 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17951 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17952 void *argp1 = 0 ;
17953 int res1 = 0 ;
17954 void *argp2 = 0 ;
17955 int res2 = 0 ;
17956 PyObject * obj0 = 0 ;
17957 PyObject * obj1 = 0 ;
17958 char * kwnames[] = {
17959 (char *) "self",(char *) "handler", NULL
17960 };
17961
17962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17964 if (!SWIG_IsOK(res1)) {
17965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17966 }
17967 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17968 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17969 if (!SWIG_IsOK(res2)) {
17970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17971 }
17972 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17973 {
17974 PyThreadState* __tstate = wxPyBeginAllowThreads();
17975 (arg1)->SetNextHandler(arg2);
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 resultobj = SWIG_Py_Void();
17980 return resultobj;
17981 fail:
17982 return NULL;
17983 }
17984
17985
17986 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17987 PyObject *resultobj = 0;
17988 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17989 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17990 void *argp1 = 0 ;
17991 int res1 = 0 ;
17992 void *argp2 = 0 ;
17993 int res2 = 0 ;
17994 PyObject * obj0 = 0 ;
17995 PyObject * obj1 = 0 ;
17996 char * kwnames[] = {
17997 (char *) "self",(char *) "handler", NULL
17998 };
17999
18000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18002 if (!SWIG_IsOK(res1)) {
18003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18004 }
18005 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18006 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18007 if (!SWIG_IsOK(res2)) {
18008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18009 }
18010 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18011 {
18012 PyThreadState* __tstate = wxPyBeginAllowThreads();
18013 (arg1)->SetPreviousHandler(arg2);
18014 wxPyEndAllowThreads(__tstate);
18015 if (PyErr_Occurred()) SWIG_fail;
18016 }
18017 resultobj = SWIG_Py_Void();
18018 return resultobj;
18019 fail:
18020 return NULL;
18021 }
18022
18023
18024 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18025 PyObject *resultobj = 0;
18026 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18027 bool result;
18028 void *argp1 = 0 ;
18029 int res1 = 0 ;
18030 PyObject *swig_obj[1] ;
18031
18032 if (!args) SWIG_fail;
18033 swig_obj[0] = args;
18034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18035 if (!SWIG_IsOK(res1)) {
18036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18037 }
18038 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18039 {
18040 PyThreadState* __tstate = wxPyBeginAllowThreads();
18041 result = (bool)(arg1)->GetEvtHandlerEnabled();
18042 wxPyEndAllowThreads(__tstate);
18043 if (PyErr_Occurred()) SWIG_fail;
18044 }
18045 {
18046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18047 }
18048 return resultobj;
18049 fail:
18050 return NULL;
18051 }
18052
18053
18054 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18055 PyObject *resultobj = 0;
18056 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18057 bool arg2 ;
18058 void *argp1 = 0 ;
18059 int res1 = 0 ;
18060 bool val2 ;
18061 int ecode2 = 0 ;
18062 PyObject * obj0 = 0 ;
18063 PyObject * obj1 = 0 ;
18064 char * kwnames[] = {
18065 (char *) "self",(char *) "enabled", NULL
18066 };
18067
18068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18070 if (!SWIG_IsOK(res1)) {
18071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18072 }
18073 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18074 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18075 if (!SWIG_IsOK(ecode2)) {
18076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18077 }
18078 arg2 = static_cast< bool >(val2);
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 (arg1)->SetEvtHandlerEnabled(arg2);
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 resultobj = SWIG_Py_Void();
18086 return resultobj;
18087 fail:
18088 return NULL;
18089 }
18090
18091
18092 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18093 PyObject *resultobj = 0;
18094 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18095 wxEvent *arg2 = 0 ;
18096 bool result;
18097 void *argp1 = 0 ;
18098 int res1 = 0 ;
18099 void *argp2 = 0 ;
18100 int res2 = 0 ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 char * kwnames[] = {
18104 (char *) "self",(char *) "event", NULL
18105 };
18106
18107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18109 if (!SWIG_IsOK(res1)) {
18110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18111 }
18112 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18114 if (!SWIG_IsOK(res2)) {
18115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18116 }
18117 if (!argp2) {
18118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18119 }
18120 arg2 = reinterpret_cast< wxEvent * >(argp2);
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 result = (bool)(arg1)->ProcessEvent(*arg2);
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 {
18128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18129 }
18130 return resultobj;
18131 fail:
18132 return NULL;
18133 }
18134
18135
18136 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj = 0;
18138 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18139 wxEvent *arg2 = 0 ;
18140 void *argp1 = 0 ;
18141 int res1 = 0 ;
18142 void *argp2 = 0 ;
18143 int res2 = 0 ;
18144 PyObject * obj0 = 0 ;
18145 PyObject * obj1 = 0 ;
18146 char * kwnames[] = {
18147 (char *) "self",(char *) "event", NULL
18148 };
18149
18150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18152 if (!SWIG_IsOK(res1)) {
18153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18154 }
18155 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18157 if (!SWIG_IsOK(res2)) {
18158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18159 }
18160 if (!argp2) {
18161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18162 }
18163 arg2 = reinterpret_cast< wxEvent * >(argp2);
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 (arg1)->AddPendingEvent(*arg2);
18167 wxPyEndAllowThreads(__tstate);
18168 if (PyErr_Occurred()) SWIG_fail;
18169 }
18170 resultobj = SWIG_Py_Void();
18171 return resultobj;
18172 fail:
18173 return NULL;
18174 }
18175
18176
18177 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18178 PyObject *resultobj = 0;
18179 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18180 void *argp1 = 0 ;
18181 int res1 = 0 ;
18182 PyObject *swig_obj[1] ;
18183
18184 if (!args) SWIG_fail;
18185 swig_obj[0] = args;
18186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18187 if (!SWIG_IsOK(res1)) {
18188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18189 }
18190 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18191 {
18192 PyThreadState* __tstate = wxPyBeginAllowThreads();
18193 (arg1)->ProcessPendingEvents();
18194 wxPyEndAllowThreads(__tstate);
18195 if (PyErr_Occurred()) SWIG_fail;
18196 }
18197 resultobj = SWIG_Py_Void();
18198 return resultobj;
18199 fail:
18200 return NULL;
18201 }
18202
18203
18204 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18205 PyObject *resultobj = 0;
18206 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18207 int arg2 ;
18208 int arg3 ;
18209 int arg4 ;
18210 PyObject *arg5 = (PyObject *) 0 ;
18211 void *argp1 = 0 ;
18212 int res1 = 0 ;
18213 int val2 ;
18214 int ecode2 = 0 ;
18215 int val3 ;
18216 int ecode3 = 0 ;
18217 int val4 ;
18218 int ecode4 = 0 ;
18219 PyObject * obj0 = 0 ;
18220 PyObject * obj1 = 0 ;
18221 PyObject * obj2 = 0 ;
18222 PyObject * obj3 = 0 ;
18223 PyObject * obj4 = 0 ;
18224 char * kwnames[] = {
18225 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18226 };
18227
18228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18230 if (!SWIG_IsOK(res1)) {
18231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18232 }
18233 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18234 ecode2 = SWIG_AsVal_int(obj1, &val2);
18235 if (!SWIG_IsOK(ecode2)) {
18236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18237 }
18238 arg2 = static_cast< int >(val2);
18239 ecode3 = SWIG_AsVal_int(obj2, &val3);
18240 if (!SWIG_IsOK(ecode3)) {
18241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18242 }
18243 arg3 = static_cast< int >(val3);
18244 ecode4 = SWIG_AsVal_int(obj3, &val4);
18245 if (!SWIG_IsOK(ecode4)) {
18246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18247 }
18248 arg4 = static_cast< int >(val4);
18249 arg5 = obj4;
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 resultobj = SWIG_Py_Void();
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj = 0;
18265 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18266 int arg2 ;
18267 int arg3 = (int) -1 ;
18268 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18269 bool result;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 int val2 ;
18273 int ecode2 = 0 ;
18274 int val3 ;
18275 int ecode3 = 0 ;
18276 int val4 ;
18277 int ecode4 = 0 ;
18278 PyObject * obj0 = 0 ;
18279 PyObject * obj1 = 0 ;
18280 PyObject * obj2 = 0 ;
18281 PyObject * obj3 = 0 ;
18282 char * kwnames[] = {
18283 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18284 };
18285
18286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18288 if (!SWIG_IsOK(res1)) {
18289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18290 }
18291 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18292 ecode2 = SWIG_AsVal_int(obj1, &val2);
18293 if (!SWIG_IsOK(ecode2)) {
18294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18295 }
18296 arg2 = static_cast< int >(val2);
18297 if (obj2) {
18298 ecode3 = SWIG_AsVal_int(obj2, &val3);
18299 if (!SWIG_IsOK(ecode3)) {
18300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18301 }
18302 arg3 = static_cast< int >(val3);
18303 }
18304 if (obj3) {
18305 ecode4 = SWIG_AsVal_int(obj3, &val4);
18306 if (!SWIG_IsOK(ecode4)) {
18307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18308 }
18309 arg4 = static_cast< wxEventType >(val4);
18310 }
18311 {
18312 PyThreadState* __tstate = wxPyBeginAllowThreads();
18313 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18314 wxPyEndAllowThreads(__tstate);
18315 if (PyErr_Occurred()) SWIG_fail;
18316 }
18317 {
18318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18319 }
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj = 0;
18328 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18329 PyObject *arg2 = (PyObject *) 0 ;
18330 bool arg3 = (bool) true ;
18331 void *argp1 = 0 ;
18332 int res1 = 0 ;
18333 bool val3 ;
18334 int ecode3 = 0 ;
18335 PyObject * obj0 = 0 ;
18336 PyObject * obj1 = 0 ;
18337 PyObject * obj2 = 0 ;
18338 char * kwnames[] = {
18339 (char *) "self",(char *) "_self",(char *) "incref", NULL
18340 };
18341
18342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18344 if (!SWIG_IsOK(res1)) {
18345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18346 }
18347 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18348 arg2 = obj1;
18349 if (obj2) {
18350 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18351 if (!SWIG_IsOK(ecode3)) {
18352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18353 }
18354 arg3 = static_cast< bool >(val3);
18355 }
18356 {
18357 PyThreadState* __tstate = wxPyBeginAllowThreads();
18358 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18359 wxPyEndAllowThreads(__tstate);
18360 if (PyErr_Occurred()) SWIG_fail;
18361 }
18362 resultobj = SWIG_Py_Void();
18363 return resultobj;
18364 fail:
18365 return NULL;
18366 }
18367
18368
18369 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18370 PyObject *obj;
18371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18372 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18373 return SWIG_Py_Void();
18374 }
18375
18376 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18377 return SWIG_Python_InitShadowInstance(args);
18378 }
18379
18380 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18381 PyObject *resultobj = 0;
18382 wxEventType result;
18383
18384 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 result = (wxEventType)wxNewEventType();
18388 wxPyEndAllowThreads(__tstate);
18389 if (PyErr_Occurred()) SWIG_fail;
18390 }
18391 resultobj = SWIG_From_int(static_cast< int >(result));
18392 return resultobj;
18393 fail:
18394 return NULL;
18395 }
18396
18397
18398 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18399 PyObject *resultobj = 0;
18400 wxEvent *arg1 = (wxEvent *) 0 ;
18401 void *argp1 = 0 ;
18402 int res1 = 0 ;
18403 PyObject *swig_obj[1] ;
18404
18405 if (!args) SWIG_fail;
18406 swig_obj[0] = args;
18407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18408 if (!SWIG_IsOK(res1)) {
18409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18410 }
18411 arg1 = reinterpret_cast< wxEvent * >(argp1);
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 delete arg1;
18415
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = SWIG_Py_Void();
18420 return resultobj;
18421 fail:
18422 return NULL;
18423 }
18424
18425
18426 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18427 PyObject *resultobj = 0;
18428 wxEvent *arg1 = (wxEvent *) 0 ;
18429 wxEventType arg2 ;
18430 void *argp1 = 0 ;
18431 int res1 = 0 ;
18432 int val2 ;
18433 int ecode2 = 0 ;
18434 PyObject * obj0 = 0 ;
18435 PyObject * obj1 = 0 ;
18436 char * kwnames[] = {
18437 (char *) "self",(char *) "typ", NULL
18438 };
18439
18440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18444 }
18445 arg1 = reinterpret_cast< wxEvent * >(argp1);
18446 ecode2 = SWIG_AsVal_int(obj1, &val2);
18447 if (!SWIG_IsOK(ecode2)) {
18448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18449 }
18450 arg2 = static_cast< wxEventType >(val2);
18451 {
18452 PyThreadState* __tstate = wxPyBeginAllowThreads();
18453 (arg1)->SetEventType(arg2);
18454 wxPyEndAllowThreads(__tstate);
18455 if (PyErr_Occurred()) SWIG_fail;
18456 }
18457 resultobj = SWIG_Py_Void();
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18465 PyObject *resultobj = 0;
18466 wxEvent *arg1 = (wxEvent *) 0 ;
18467 wxEventType result;
18468 void *argp1 = 0 ;
18469 int res1 = 0 ;
18470 PyObject *swig_obj[1] ;
18471
18472 if (!args) SWIG_fail;
18473 swig_obj[0] = args;
18474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18475 if (!SWIG_IsOK(res1)) {
18476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18477 }
18478 arg1 = reinterpret_cast< wxEvent * >(argp1);
18479 {
18480 PyThreadState* __tstate = wxPyBeginAllowThreads();
18481 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 resultobj = SWIG_From_int(static_cast< int >(result));
18486 return resultobj;
18487 fail:
18488 return NULL;
18489 }
18490
18491
18492 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18493 PyObject *resultobj = 0;
18494 wxEvent *arg1 = (wxEvent *) 0 ;
18495 wxObject *result = 0 ;
18496 void *argp1 = 0 ;
18497 int res1 = 0 ;
18498 PyObject *swig_obj[1] ;
18499
18500 if (!args) SWIG_fail;
18501 swig_obj[0] = args;
18502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18503 if (!SWIG_IsOK(res1)) {
18504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18505 }
18506 arg1 = reinterpret_cast< wxEvent * >(argp1);
18507 {
18508 PyThreadState* __tstate = wxPyBeginAllowThreads();
18509 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18510 wxPyEndAllowThreads(__tstate);
18511 if (PyErr_Occurred()) SWIG_fail;
18512 }
18513 {
18514 resultobj = wxPyMake_wxObject(result, (bool)0);
18515 }
18516 return resultobj;
18517 fail:
18518 return NULL;
18519 }
18520
18521
18522 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj = 0;
18524 wxEvent *arg1 = (wxEvent *) 0 ;
18525 wxObject *arg2 = (wxObject *) 0 ;
18526 void *argp1 = 0 ;
18527 int res1 = 0 ;
18528 void *argp2 = 0 ;
18529 int res2 = 0 ;
18530 PyObject * obj0 = 0 ;
18531 PyObject * obj1 = 0 ;
18532 char * kwnames[] = {
18533 (char *) "self",(char *) "obj", NULL
18534 };
18535
18536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18538 if (!SWIG_IsOK(res1)) {
18539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18540 }
18541 arg1 = reinterpret_cast< wxEvent * >(argp1);
18542 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18543 if (!SWIG_IsOK(res2)) {
18544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18545 }
18546 arg2 = reinterpret_cast< wxObject * >(argp2);
18547 {
18548 PyThreadState* __tstate = wxPyBeginAllowThreads();
18549 (arg1)->SetEventObject(arg2);
18550 wxPyEndAllowThreads(__tstate);
18551 if (PyErr_Occurred()) SWIG_fail;
18552 }
18553 resultobj = SWIG_Py_Void();
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18561 PyObject *resultobj = 0;
18562 wxEvent *arg1 = (wxEvent *) 0 ;
18563 long result;
18564 void *argp1 = 0 ;
18565 int res1 = 0 ;
18566 PyObject *swig_obj[1] ;
18567
18568 if (!args) SWIG_fail;
18569 swig_obj[0] = args;
18570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18571 if (!SWIG_IsOK(res1)) {
18572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18573 }
18574 arg1 = reinterpret_cast< wxEvent * >(argp1);
18575 {
18576 PyThreadState* __tstate = wxPyBeginAllowThreads();
18577 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18578 wxPyEndAllowThreads(__tstate);
18579 if (PyErr_Occurred()) SWIG_fail;
18580 }
18581 resultobj = SWIG_From_long(static_cast< long >(result));
18582 return resultobj;
18583 fail:
18584 return NULL;
18585 }
18586
18587
18588 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj = 0;
18590 wxEvent *arg1 = (wxEvent *) 0 ;
18591 long arg2 = (long) 0 ;
18592 void *argp1 = 0 ;
18593 int res1 = 0 ;
18594 long val2 ;
18595 int ecode2 = 0 ;
18596 PyObject * obj0 = 0 ;
18597 PyObject * obj1 = 0 ;
18598 char * kwnames[] = {
18599 (char *) "self",(char *) "ts", NULL
18600 };
18601
18602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18604 if (!SWIG_IsOK(res1)) {
18605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18606 }
18607 arg1 = reinterpret_cast< wxEvent * >(argp1);
18608 if (obj1) {
18609 ecode2 = SWIG_AsVal_long(obj1, &val2);
18610 if (!SWIG_IsOK(ecode2)) {
18611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18612 }
18613 arg2 = static_cast< long >(val2);
18614 }
18615 {
18616 PyThreadState* __tstate = wxPyBeginAllowThreads();
18617 (arg1)->SetTimestamp(arg2);
18618 wxPyEndAllowThreads(__tstate);
18619 if (PyErr_Occurred()) SWIG_fail;
18620 }
18621 resultobj = SWIG_Py_Void();
18622 return resultobj;
18623 fail:
18624 return NULL;
18625 }
18626
18627
18628 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18629 PyObject *resultobj = 0;
18630 wxEvent *arg1 = (wxEvent *) 0 ;
18631 int result;
18632 void *argp1 = 0 ;
18633 int res1 = 0 ;
18634 PyObject *swig_obj[1] ;
18635
18636 if (!args) SWIG_fail;
18637 swig_obj[0] = args;
18638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18639 if (!SWIG_IsOK(res1)) {
18640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18641 }
18642 arg1 = reinterpret_cast< wxEvent * >(argp1);
18643 {
18644 PyThreadState* __tstate = wxPyBeginAllowThreads();
18645 result = (int)((wxEvent const *)arg1)->GetId();
18646 wxPyEndAllowThreads(__tstate);
18647 if (PyErr_Occurred()) SWIG_fail;
18648 }
18649 resultobj = SWIG_From_int(static_cast< int >(result));
18650 return resultobj;
18651 fail:
18652 return NULL;
18653 }
18654
18655
18656 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18657 PyObject *resultobj = 0;
18658 wxEvent *arg1 = (wxEvent *) 0 ;
18659 int arg2 ;
18660 void *argp1 = 0 ;
18661 int res1 = 0 ;
18662 int val2 ;
18663 int ecode2 = 0 ;
18664 PyObject * obj0 = 0 ;
18665 PyObject * obj1 = 0 ;
18666 char * kwnames[] = {
18667 (char *) "self",(char *) "Id", NULL
18668 };
18669
18670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18672 if (!SWIG_IsOK(res1)) {
18673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18674 }
18675 arg1 = reinterpret_cast< wxEvent * >(argp1);
18676 ecode2 = SWIG_AsVal_int(obj1, &val2);
18677 if (!SWIG_IsOK(ecode2)) {
18678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18679 }
18680 arg2 = static_cast< int >(val2);
18681 {
18682 PyThreadState* __tstate = wxPyBeginAllowThreads();
18683 (arg1)->SetId(arg2);
18684 wxPyEndAllowThreads(__tstate);
18685 if (PyErr_Occurred()) SWIG_fail;
18686 }
18687 resultobj = SWIG_Py_Void();
18688 return resultobj;
18689 fail:
18690 return NULL;
18691 }
18692
18693
18694 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18695 PyObject *resultobj = 0;
18696 wxEvent *arg1 = (wxEvent *) 0 ;
18697 bool result;
18698 void *argp1 = 0 ;
18699 int res1 = 0 ;
18700 PyObject *swig_obj[1] ;
18701
18702 if (!args) SWIG_fail;
18703 swig_obj[0] = args;
18704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18705 if (!SWIG_IsOK(res1)) {
18706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18707 }
18708 arg1 = reinterpret_cast< wxEvent * >(argp1);
18709 {
18710 PyThreadState* __tstate = wxPyBeginAllowThreads();
18711 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18712 wxPyEndAllowThreads(__tstate);
18713 if (PyErr_Occurred()) SWIG_fail;
18714 }
18715 {
18716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18717 }
18718 return resultobj;
18719 fail:
18720 return NULL;
18721 }
18722
18723
18724 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18725 PyObject *resultobj = 0;
18726 wxEvent *arg1 = (wxEvent *) 0 ;
18727 bool arg2 = (bool) true ;
18728 void *argp1 = 0 ;
18729 int res1 = 0 ;
18730 bool val2 ;
18731 int ecode2 = 0 ;
18732 PyObject * obj0 = 0 ;
18733 PyObject * obj1 = 0 ;
18734 char * kwnames[] = {
18735 (char *) "self",(char *) "skip", NULL
18736 };
18737
18738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18740 if (!SWIG_IsOK(res1)) {
18741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18742 }
18743 arg1 = reinterpret_cast< wxEvent * >(argp1);
18744 if (obj1) {
18745 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18746 if (!SWIG_IsOK(ecode2)) {
18747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18748 }
18749 arg2 = static_cast< bool >(val2);
18750 }
18751 {
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 (arg1)->Skip(arg2);
18754 wxPyEndAllowThreads(__tstate);
18755 if (PyErr_Occurred()) SWIG_fail;
18756 }
18757 resultobj = SWIG_Py_Void();
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18765 PyObject *resultobj = 0;
18766 wxEvent *arg1 = (wxEvent *) 0 ;
18767 bool result;
18768 void *argp1 = 0 ;
18769 int res1 = 0 ;
18770 PyObject *swig_obj[1] ;
18771
18772 if (!args) SWIG_fail;
18773 swig_obj[0] = args;
18774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18775 if (!SWIG_IsOK(res1)) {
18776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18777 }
18778 arg1 = reinterpret_cast< wxEvent * >(argp1);
18779 {
18780 PyThreadState* __tstate = wxPyBeginAllowThreads();
18781 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18782 wxPyEndAllowThreads(__tstate);
18783 if (PyErr_Occurred()) SWIG_fail;
18784 }
18785 {
18786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18787 }
18788 return resultobj;
18789 fail:
18790 return NULL;
18791 }
18792
18793
18794 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18795 PyObject *resultobj = 0;
18796 wxEvent *arg1 = (wxEvent *) 0 ;
18797 bool result;
18798 void *argp1 = 0 ;
18799 int res1 = 0 ;
18800 PyObject *swig_obj[1] ;
18801
18802 if (!args) SWIG_fail;
18803 swig_obj[0] = args;
18804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18805 if (!SWIG_IsOK(res1)) {
18806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18807 }
18808 arg1 = reinterpret_cast< wxEvent * >(argp1);
18809 {
18810 PyThreadState* __tstate = wxPyBeginAllowThreads();
18811 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18812 wxPyEndAllowThreads(__tstate);
18813 if (PyErr_Occurred()) SWIG_fail;
18814 }
18815 {
18816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18817 }
18818 return resultobj;
18819 fail:
18820 return NULL;
18821 }
18822
18823
18824 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 PyObject *resultobj = 0;
18826 wxEvent *arg1 = (wxEvent *) 0 ;
18827 int result;
18828 void *argp1 = 0 ;
18829 int res1 = 0 ;
18830 PyObject *swig_obj[1] ;
18831
18832 if (!args) SWIG_fail;
18833 swig_obj[0] = args;
18834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18835 if (!SWIG_IsOK(res1)) {
18836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18837 }
18838 arg1 = reinterpret_cast< wxEvent * >(argp1);
18839 {
18840 PyThreadState* __tstate = wxPyBeginAllowThreads();
18841 result = (int)(arg1)->StopPropagation();
18842 wxPyEndAllowThreads(__tstate);
18843 if (PyErr_Occurred()) SWIG_fail;
18844 }
18845 resultobj = SWIG_From_int(static_cast< int >(result));
18846 return resultobj;
18847 fail:
18848 return NULL;
18849 }
18850
18851
18852 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18853 PyObject *resultobj = 0;
18854 wxEvent *arg1 = (wxEvent *) 0 ;
18855 int arg2 ;
18856 void *argp1 = 0 ;
18857 int res1 = 0 ;
18858 int val2 ;
18859 int ecode2 = 0 ;
18860 PyObject * obj0 = 0 ;
18861 PyObject * obj1 = 0 ;
18862 char * kwnames[] = {
18863 (char *) "self",(char *) "propagationLevel", NULL
18864 };
18865
18866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18868 if (!SWIG_IsOK(res1)) {
18869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18870 }
18871 arg1 = reinterpret_cast< wxEvent * >(argp1);
18872 ecode2 = SWIG_AsVal_int(obj1, &val2);
18873 if (!SWIG_IsOK(ecode2)) {
18874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18875 }
18876 arg2 = static_cast< int >(val2);
18877 {
18878 PyThreadState* __tstate = wxPyBeginAllowThreads();
18879 (arg1)->ResumePropagation(arg2);
18880 wxPyEndAllowThreads(__tstate);
18881 if (PyErr_Occurred()) SWIG_fail;
18882 }
18883 resultobj = SWIG_Py_Void();
18884 return resultobj;
18885 fail:
18886 return NULL;
18887 }
18888
18889
18890 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18891 PyObject *resultobj = 0;
18892 wxEvent *arg1 = (wxEvent *) 0 ;
18893 wxEvent *result = 0 ;
18894 void *argp1 = 0 ;
18895 int res1 = 0 ;
18896 PyObject *swig_obj[1] ;
18897
18898 if (!args) SWIG_fail;
18899 swig_obj[0] = args;
18900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18901 if (!SWIG_IsOK(res1)) {
18902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18903 }
18904 arg1 = reinterpret_cast< wxEvent * >(argp1);
18905 {
18906 PyThreadState* __tstate = wxPyBeginAllowThreads();
18907 result = (wxEvent *)(arg1)->Clone();
18908 wxPyEndAllowThreads(__tstate);
18909 if (PyErr_Occurred()) SWIG_fail;
18910 }
18911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18912 return resultobj;
18913 fail:
18914 return NULL;
18915 }
18916
18917
18918 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18919 PyObject *obj;
18920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18921 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18922 return SWIG_Py_Void();
18923 }
18924
18925 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj = 0;
18927 wxEvent *arg1 = 0 ;
18928 wxPropagationDisabler *result = 0 ;
18929 void *argp1 = 0 ;
18930 int res1 = 0 ;
18931 PyObject * obj0 = 0 ;
18932 char * kwnames[] = {
18933 (char *) "event", NULL
18934 };
18935
18936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18937 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18938 if (!SWIG_IsOK(res1)) {
18939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18940 }
18941 if (!argp1) {
18942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18943 }
18944 arg1 = reinterpret_cast< wxEvent * >(argp1);
18945 {
18946 PyThreadState* __tstate = wxPyBeginAllowThreads();
18947 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18948 wxPyEndAllowThreads(__tstate);
18949 if (PyErr_Occurred()) SWIG_fail;
18950 }
18951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18952 return resultobj;
18953 fail:
18954 return NULL;
18955 }
18956
18957
18958 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18959 PyObject *resultobj = 0;
18960 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18961 void *argp1 = 0 ;
18962 int res1 = 0 ;
18963 PyObject *swig_obj[1] ;
18964
18965 if (!args) SWIG_fail;
18966 swig_obj[0] = args;
18967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18968 if (!SWIG_IsOK(res1)) {
18969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18970 }
18971 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18972 {
18973 PyThreadState* __tstate = wxPyBeginAllowThreads();
18974 delete arg1;
18975
18976 wxPyEndAllowThreads(__tstate);
18977 if (PyErr_Occurred()) SWIG_fail;
18978 }
18979 resultobj = SWIG_Py_Void();
18980 return resultobj;
18981 fail:
18982 return NULL;
18983 }
18984
18985
18986 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18987 PyObject *obj;
18988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18989 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18990 return SWIG_Py_Void();
18991 }
18992
18993 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18994 return SWIG_Python_InitShadowInstance(args);
18995 }
18996
18997 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18998 PyObject *resultobj = 0;
18999 wxEvent *arg1 = 0 ;
19000 wxPropagateOnce *result = 0 ;
19001 void *argp1 = 0 ;
19002 int res1 = 0 ;
19003 PyObject * obj0 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "event", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19009 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19012 }
19013 if (!argp1) {
19014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19015 }
19016 arg1 = reinterpret_cast< wxEvent * >(argp1);
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19031 PyObject *resultobj = 0;
19032 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19033 void *argp1 = 0 ;
19034 int res1 = 0 ;
19035 PyObject *swig_obj[1] ;
19036
19037 if (!args) SWIG_fail;
19038 swig_obj[0] = args;
19039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19040 if (!SWIG_IsOK(res1)) {
19041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19042 }
19043 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19044 {
19045 PyThreadState* __tstate = wxPyBeginAllowThreads();
19046 delete arg1;
19047
19048 wxPyEndAllowThreads(__tstate);
19049 if (PyErr_Occurred()) SWIG_fail;
19050 }
19051 resultobj = SWIG_Py_Void();
19052 return resultobj;
19053 fail:
19054 return NULL;
19055 }
19056
19057
19058 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19059 PyObject *obj;
19060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19061 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19062 return SWIG_Py_Void();
19063 }
19064
19065 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19066 return SWIG_Python_InitShadowInstance(args);
19067 }
19068
19069 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19070 PyObject *resultobj = 0;
19071 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19072 int arg2 = (int) 0 ;
19073 wxCommandEvent *result = 0 ;
19074 int val1 ;
19075 int ecode1 = 0 ;
19076 int val2 ;
19077 int ecode2 = 0 ;
19078 PyObject * obj0 = 0 ;
19079 PyObject * obj1 = 0 ;
19080 char * kwnames[] = {
19081 (char *) "commandType",(char *) "winid", NULL
19082 };
19083
19084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19085 if (obj0) {
19086 ecode1 = SWIG_AsVal_int(obj0, &val1);
19087 if (!SWIG_IsOK(ecode1)) {
19088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19089 }
19090 arg1 = static_cast< wxEventType >(val1);
19091 }
19092 if (obj1) {
19093 ecode2 = SWIG_AsVal_int(obj1, &val2);
19094 if (!SWIG_IsOK(ecode2)) {
19095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19096 }
19097 arg2 = static_cast< int >(val2);
19098 }
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19113 PyObject *resultobj = 0;
19114 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19115 int result;
19116 void *argp1 = 0 ;
19117 int res1 = 0 ;
19118 PyObject *swig_obj[1] ;
19119
19120 if (!args) SWIG_fail;
19121 swig_obj[0] = args;
19122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19123 if (!SWIG_IsOK(res1)) {
19124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19125 }
19126 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19127 {
19128 PyThreadState* __tstate = wxPyBeginAllowThreads();
19129 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19130 wxPyEndAllowThreads(__tstate);
19131 if (PyErr_Occurred()) SWIG_fail;
19132 }
19133 resultobj = SWIG_From_int(static_cast< int >(result));
19134 return resultobj;
19135 fail:
19136 return NULL;
19137 }
19138
19139
19140 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj = 0;
19142 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19143 wxString *arg2 = 0 ;
19144 void *argp1 = 0 ;
19145 int res1 = 0 ;
19146 bool temp2 = false ;
19147 PyObject * obj0 = 0 ;
19148 PyObject * obj1 = 0 ;
19149 char * kwnames[] = {
19150 (char *) "self",(char *) "s", NULL
19151 };
19152
19153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19155 if (!SWIG_IsOK(res1)) {
19156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19157 }
19158 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19159 {
19160 arg2 = wxString_in_helper(obj1);
19161 if (arg2 == NULL) SWIG_fail;
19162 temp2 = true;
19163 }
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 (arg1)->SetString((wxString const &)*arg2);
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 resultobj = SWIG_Py_Void();
19171 {
19172 if (temp2)
19173 delete arg2;
19174 }
19175 return resultobj;
19176 fail:
19177 {
19178 if (temp2)
19179 delete arg2;
19180 }
19181 return NULL;
19182 }
19183
19184
19185 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19186 PyObject *resultobj = 0;
19187 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19188 wxString result;
19189 void *argp1 = 0 ;
19190 int res1 = 0 ;
19191 PyObject *swig_obj[1] ;
19192
19193 if (!args) SWIG_fail;
19194 swig_obj[0] = args;
19195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19196 if (!SWIG_IsOK(res1)) {
19197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19198 }
19199 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19200 {
19201 PyThreadState* __tstate = wxPyBeginAllowThreads();
19202 result = ((wxCommandEvent const *)arg1)->GetString();
19203 wxPyEndAllowThreads(__tstate);
19204 if (PyErr_Occurred()) SWIG_fail;
19205 }
19206 {
19207 #if wxUSE_UNICODE
19208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19209 #else
19210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19211 #endif
19212 }
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19220 PyObject *resultobj = 0;
19221 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19222 bool result;
19223 void *argp1 = 0 ;
19224 int res1 = 0 ;
19225 PyObject *swig_obj[1] ;
19226
19227 if (!args) SWIG_fail;
19228 swig_obj[0] = args;
19229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19230 if (!SWIG_IsOK(res1)) {
19231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19232 }
19233 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19234 {
19235 PyThreadState* __tstate = wxPyBeginAllowThreads();
19236 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19250 PyObject *resultobj = 0;
19251 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19252 bool result;
19253 void *argp1 = 0 ;
19254 int res1 = 0 ;
19255 PyObject *swig_obj[1] ;
19256
19257 if (!args) SWIG_fail;
19258 swig_obj[0] = args;
19259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19260 if (!SWIG_IsOK(res1)) {
19261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19262 }
19263 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 {
19271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19272 }
19273 return resultobj;
19274 fail:
19275 return NULL;
19276 }
19277
19278
19279 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19280 PyObject *resultobj = 0;
19281 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19282 long arg2 ;
19283 void *argp1 = 0 ;
19284 int res1 = 0 ;
19285 long val2 ;
19286 int ecode2 = 0 ;
19287 PyObject * obj0 = 0 ;
19288 PyObject * obj1 = 0 ;
19289 char * kwnames[] = {
19290 (char *) "self",(char *) "extraLong", NULL
19291 };
19292
19293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19295 if (!SWIG_IsOK(res1)) {
19296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19297 }
19298 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19299 ecode2 = SWIG_AsVal_long(obj1, &val2);
19300 if (!SWIG_IsOK(ecode2)) {
19301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19302 }
19303 arg2 = static_cast< long >(val2);
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 (arg1)->SetExtraLong(arg2);
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 resultobj = SWIG_Py_Void();
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19318 PyObject *resultobj = 0;
19319 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19320 long result;
19321 void *argp1 = 0 ;
19322 int res1 = 0 ;
19323 PyObject *swig_obj[1] ;
19324
19325 if (!args) SWIG_fail;
19326 swig_obj[0] = args;
19327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19328 if (!SWIG_IsOK(res1)) {
19329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19330 }
19331 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 resultobj = SWIG_From_long(static_cast< long >(result));
19339 return resultobj;
19340 fail:
19341 return NULL;
19342 }
19343
19344
19345 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj = 0;
19347 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19348 int arg2 ;
19349 void *argp1 = 0 ;
19350 int res1 = 0 ;
19351 int val2 ;
19352 int ecode2 = 0 ;
19353 PyObject * obj0 = 0 ;
19354 PyObject * obj1 = 0 ;
19355 char * kwnames[] = {
19356 (char *) "self",(char *) "i", NULL
19357 };
19358
19359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19363 }
19364 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19365 ecode2 = SWIG_AsVal_int(obj1, &val2);
19366 if (!SWIG_IsOK(ecode2)) {
19367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19368 }
19369 arg2 = static_cast< int >(val2);
19370 {
19371 PyThreadState* __tstate = wxPyBeginAllowThreads();
19372 (arg1)->SetInt(arg2);
19373 wxPyEndAllowThreads(__tstate);
19374 if (PyErr_Occurred()) SWIG_fail;
19375 }
19376 resultobj = SWIG_Py_Void();
19377 return resultobj;
19378 fail:
19379 return NULL;
19380 }
19381
19382
19383 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19384 PyObject *resultobj = 0;
19385 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19386 int result;
19387 void *argp1 = 0 ;
19388 int res1 = 0 ;
19389 PyObject *swig_obj[1] ;
19390
19391 if (!args) SWIG_fail;
19392 swig_obj[0] = args;
19393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19394 if (!SWIG_IsOK(res1)) {
19395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19396 }
19397 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19398 {
19399 PyThreadState* __tstate = wxPyBeginAllowThreads();
19400 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19401 wxPyEndAllowThreads(__tstate);
19402 if (PyErr_Occurred()) SWIG_fail;
19403 }
19404 resultobj = SWIG_From_int(static_cast< int >(result));
19405 return resultobj;
19406 fail:
19407 return NULL;
19408 }
19409
19410
19411 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19412 PyObject *resultobj = 0;
19413 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19414 PyObject *result = 0 ;
19415 void *argp1 = 0 ;
19416 int res1 = 0 ;
19417 PyObject *swig_obj[1] ;
19418
19419 if (!args) SWIG_fail;
19420 swig_obj[0] = args;
19421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19422 if (!SWIG_IsOK(res1)) {
19423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19424 }
19425 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19426 {
19427 PyThreadState* __tstate = wxPyBeginAllowThreads();
19428 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19429 wxPyEndAllowThreads(__tstate);
19430 if (PyErr_Occurred()) SWIG_fail;
19431 }
19432 resultobj = result;
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19440 PyObject *resultobj = 0;
19441 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19442 PyObject *arg2 = (PyObject *) 0 ;
19443 void *argp1 = 0 ;
19444 int res1 = 0 ;
19445 PyObject * obj0 = 0 ;
19446 PyObject * obj1 = 0 ;
19447 char * kwnames[] = {
19448 (char *) "self",(char *) "clientData", NULL
19449 };
19450
19451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19453 if (!SWIG_IsOK(res1)) {
19454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19455 }
19456 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19457 arg2 = obj1;
19458 {
19459 PyThreadState* __tstate = wxPyBeginAllowThreads();
19460 wxCommandEvent_SetClientData(arg1,arg2);
19461 wxPyEndAllowThreads(__tstate);
19462 if (PyErr_Occurred()) SWIG_fail;
19463 }
19464 resultobj = SWIG_Py_Void();
19465 return resultobj;
19466 fail:
19467 return NULL;
19468 }
19469
19470
19471 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19472 PyObject *resultobj = 0;
19473 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19474 wxEvent *result = 0 ;
19475 void *argp1 = 0 ;
19476 int res1 = 0 ;
19477 PyObject *swig_obj[1] ;
19478
19479 if (!args) SWIG_fail;
19480 swig_obj[0] = args;
19481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19482 if (!SWIG_IsOK(res1)) {
19483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19484 }
19485 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19486 {
19487 PyThreadState* __tstate = wxPyBeginAllowThreads();
19488 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19489 wxPyEndAllowThreads(__tstate);
19490 if (PyErr_Occurred()) SWIG_fail;
19491 }
19492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19493 return resultobj;
19494 fail:
19495 return NULL;
19496 }
19497
19498
19499 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19500 PyObject *obj;
19501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19502 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19503 return SWIG_Py_Void();
19504 }
19505
19506 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19507 return SWIG_Python_InitShadowInstance(args);
19508 }
19509
19510 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj = 0;
19512 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19513 int arg2 = (int) 0 ;
19514 wxNotifyEvent *result = 0 ;
19515 int val1 ;
19516 int ecode1 = 0 ;
19517 int val2 ;
19518 int ecode2 = 0 ;
19519 PyObject * obj0 = 0 ;
19520 PyObject * obj1 = 0 ;
19521 char * kwnames[] = {
19522 (char *) "commandType",(char *) "winid", NULL
19523 };
19524
19525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19526 if (obj0) {
19527 ecode1 = SWIG_AsVal_int(obj0, &val1);
19528 if (!SWIG_IsOK(ecode1)) {
19529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19530 }
19531 arg1 = static_cast< wxEventType >(val1);
19532 }
19533 if (obj1) {
19534 ecode2 = SWIG_AsVal_int(obj1, &val2);
19535 if (!SWIG_IsOK(ecode2)) {
19536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19537 }
19538 arg2 = static_cast< int >(val2);
19539 }
19540 {
19541 PyThreadState* __tstate = wxPyBeginAllowThreads();
19542 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19543 wxPyEndAllowThreads(__tstate);
19544 if (PyErr_Occurred()) SWIG_fail;
19545 }
19546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19547 return resultobj;
19548 fail:
19549 return NULL;
19550 }
19551
19552
19553 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19554 PyObject *resultobj = 0;
19555 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19556 void *argp1 = 0 ;
19557 int res1 = 0 ;
19558 PyObject *swig_obj[1] ;
19559
19560 if (!args) SWIG_fail;
19561 swig_obj[0] = args;
19562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19563 if (!SWIG_IsOK(res1)) {
19564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19565 }
19566 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19567 {
19568 PyThreadState* __tstate = wxPyBeginAllowThreads();
19569 (arg1)->Veto();
19570 wxPyEndAllowThreads(__tstate);
19571 if (PyErr_Occurred()) SWIG_fail;
19572 }
19573 resultobj = SWIG_Py_Void();
19574 return resultobj;
19575 fail:
19576 return NULL;
19577 }
19578
19579
19580 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19581 PyObject *resultobj = 0;
19582 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19583 void *argp1 = 0 ;
19584 int res1 = 0 ;
19585 PyObject *swig_obj[1] ;
19586
19587 if (!args) SWIG_fail;
19588 swig_obj[0] = args;
19589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19590 if (!SWIG_IsOK(res1)) {
19591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19592 }
19593 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19594 {
19595 PyThreadState* __tstate = wxPyBeginAllowThreads();
19596 (arg1)->Allow();
19597 wxPyEndAllowThreads(__tstate);
19598 if (PyErr_Occurred()) SWIG_fail;
19599 }
19600 resultobj = SWIG_Py_Void();
19601 return resultobj;
19602 fail:
19603 return NULL;
19604 }
19605
19606
19607 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19608 PyObject *resultobj = 0;
19609 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19610 bool result;
19611 void *argp1 = 0 ;
19612 int res1 = 0 ;
19613 PyObject *swig_obj[1] ;
19614
19615 if (!args) SWIG_fail;
19616 swig_obj[0] = args;
19617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19618 if (!SWIG_IsOK(res1)) {
19619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19620 }
19621 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 result = (bool)(arg1)->IsAllowed();
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 {
19629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19630 }
19631 return resultobj;
19632 fail:
19633 return NULL;
19634 }
19635
19636
19637 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19638 PyObject *obj;
19639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19640 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19641 return SWIG_Py_Void();
19642 }
19643
19644 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 return SWIG_Python_InitShadowInstance(args);
19646 }
19647
19648 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19649 PyObject *resultobj = 0;
19650 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19651 int arg2 = (int) 0 ;
19652 int arg3 = (int) 0 ;
19653 int arg4 = (int) 0 ;
19654 wxScrollEvent *result = 0 ;
19655 int val1 ;
19656 int ecode1 = 0 ;
19657 int val2 ;
19658 int ecode2 = 0 ;
19659 int val3 ;
19660 int ecode3 = 0 ;
19661 int val4 ;
19662 int ecode4 = 0 ;
19663 PyObject * obj0 = 0 ;
19664 PyObject * obj1 = 0 ;
19665 PyObject * obj2 = 0 ;
19666 PyObject * obj3 = 0 ;
19667 char * kwnames[] = {
19668 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19669 };
19670
19671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19672 if (obj0) {
19673 ecode1 = SWIG_AsVal_int(obj0, &val1);
19674 if (!SWIG_IsOK(ecode1)) {
19675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19676 }
19677 arg1 = static_cast< wxEventType >(val1);
19678 }
19679 if (obj1) {
19680 ecode2 = SWIG_AsVal_int(obj1, &val2);
19681 if (!SWIG_IsOK(ecode2)) {
19682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19683 }
19684 arg2 = static_cast< int >(val2);
19685 }
19686 if (obj2) {
19687 ecode3 = SWIG_AsVal_int(obj2, &val3);
19688 if (!SWIG_IsOK(ecode3)) {
19689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19690 }
19691 arg3 = static_cast< int >(val3);
19692 }
19693 if (obj3) {
19694 ecode4 = SWIG_AsVal_int(obj3, &val4);
19695 if (!SWIG_IsOK(ecode4)) {
19696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19697 }
19698 arg4 = static_cast< int >(val4);
19699 }
19700 {
19701 PyThreadState* __tstate = wxPyBeginAllowThreads();
19702 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19703 wxPyEndAllowThreads(__tstate);
19704 if (PyErr_Occurred()) SWIG_fail;
19705 }
19706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19714 PyObject *resultobj = 0;
19715 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19716 int result;
19717 void *argp1 = 0 ;
19718 int res1 = 0 ;
19719 PyObject *swig_obj[1] ;
19720
19721 if (!args) SWIG_fail;
19722 swig_obj[0] = args;
19723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19724 if (!SWIG_IsOK(res1)) {
19725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19726 }
19727 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_From_int(static_cast< int >(result));
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19742 PyObject *resultobj = 0;
19743 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19744 int result;
19745 void *argp1 = 0 ;
19746 int res1 = 0 ;
19747 PyObject *swig_obj[1] ;
19748
19749 if (!args) SWIG_fail;
19750 swig_obj[0] = args;
19751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19754 }
19755 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19759 wxPyEndAllowThreads(__tstate);
19760 if (PyErr_Occurred()) SWIG_fail;
19761 }
19762 resultobj = SWIG_From_int(static_cast< int >(result));
19763 return resultobj;
19764 fail:
19765 return NULL;
19766 }
19767
19768
19769 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19770 PyObject *resultobj = 0;
19771 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19772 int arg2 ;
19773 void *argp1 = 0 ;
19774 int res1 = 0 ;
19775 int val2 ;
19776 int ecode2 = 0 ;
19777 PyObject * obj0 = 0 ;
19778 PyObject * obj1 = 0 ;
19779 char * kwnames[] = {
19780 (char *) "self",(char *) "orient", NULL
19781 };
19782
19783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19785 if (!SWIG_IsOK(res1)) {
19786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19787 }
19788 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19789 ecode2 = SWIG_AsVal_int(obj1, &val2);
19790 if (!SWIG_IsOK(ecode2)) {
19791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19792 }
19793 arg2 = static_cast< int >(val2);
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 (arg1)->SetOrientation(arg2);
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 resultobj = SWIG_Py_Void();
19801 return resultobj;
19802 fail:
19803 return NULL;
19804 }
19805
19806
19807 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj = 0;
19809 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19810 int arg2 ;
19811 void *argp1 = 0 ;
19812 int res1 = 0 ;
19813 int val2 ;
19814 int ecode2 = 0 ;
19815 PyObject * obj0 = 0 ;
19816 PyObject * obj1 = 0 ;
19817 char * kwnames[] = {
19818 (char *) "self",(char *) "pos", NULL
19819 };
19820
19821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19825 }
19826 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19827 ecode2 = SWIG_AsVal_int(obj1, &val2);
19828 if (!SWIG_IsOK(ecode2)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19830 }
19831 arg2 = static_cast< int >(val2);
19832 {
19833 PyThreadState* __tstate = wxPyBeginAllowThreads();
19834 (arg1)->SetPosition(arg2);
19835 wxPyEndAllowThreads(__tstate);
19836 if (PyErr_Occurred()) SWIG_fail;
19837 }
19838 resultobj = SWIG_Py_Void();
19839 return resultobj;
19840 fail:
19841 return NULL;
19842 }
19843
19844
19845 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19846 PyObject *obj;
19847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19848 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19849 return SWIG_Py_Void();
19850 }
19851
19852 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19853 return SWIG_Python_InitShadowInstance(args);
19854 }
19855
19856 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19857 PyObject *resultobj = 0;
19858 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19859 int arg2 = (int) 0 ;
19860 int arg3 = (int) 0 ;
19861 wxScrollWinEvent *result = 0 ;
19862 int val1 ;
19863 int ecode1 = 0 ;
19864 int val2 ;
19865 int ecode2 = 0 ;
19866 int val3 ;
19867 int ecode3 = 0 ;
19868 PyObject * obj0 = 0 ;
19869 PyObject * obj1 = 0 ;
19870 PyObject * obj2 = 0 ;
19871 char * kwnames[] = {
19872 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19873 };
19874
19875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19876 if (obj0) {
19877 ecode1 = SWIG_AsVal_int(obj0, &val1);
19878 if (!SWIG_IsOK(ecode1)) {
19879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19880 }
19881 arg1 = static_cast< wxEventType >(val1);
19882 }
19883 if (obj1) {
19884 ecode2 = SWIG_AsVal_int(obj1, &val2);
19885 if (!SWIG_IsOK(ecode2)) {
19886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19887 }
19888 arg2 = static_cast< int >(val2);
19889 }
19890 if (obj2) {
19891 ecode3 = SWIG_AsVal_int(obj2, &val3);
19892 if (!SWIG_IsOK(ecode3)) {
19893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19894 }
19895 arg3 = static_cast< int >(val3);
19896 }
19897 {
19898 PyThreadState* __tstate = wxPyBeginAllowThreads();
19899 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19911 PyObject *resultobj = 0;
19912 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19913 int result;
19914 void *argp1 = 0 ;
19915 int res1 = 0 ;
19916 PyObject *swig_obj[1] ;
19917
19918 if (!args) SWIG_fail;
19919 swig_obj[0] = args;
19920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19921 if (!SWIG_IsOK(res1)) {
19922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19923 }
19924 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19925 {
19926 PyThreadState* __tstate = wxPyBeginAllowThreads();
19927 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19928 wxPyEndAllowThreads(__tstate);
19929 if (PyErr_Occurred()) SWIG_fail;
19930 }
19931 resultobj = SWIG_From_int(static_cast< int >(result));
19932 return resultobj;
19933 fail:
19934 return NULL;
19935 }
19936
19937
19938 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19939 PyObject *resultobj = 0;
19940 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19941 int result;
19942 void *argp1 = 0 ;
19943 int res1 = 0 ;
19944 PyObject *swig_obj[1] ;
19945
19946 if (!args) SWIG_fail;
19947 swig_obj[0] = args;
19948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19949 if (!SWIG_IsOK(res1)) {
19950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19951 }
19952 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19953 {
19954 PyThreadState* __tstate = wxPyBeginAllowThreads();
19955 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19956 wxPyEndAllowThreads(__tstate);
19957 if (PyErr_Occurred()) SWIG_fail;
19958 }
19959 resultobj = SWIG_From_int(static_cast< int >(result));
19960 return resultobj;
19961 fail:
19962 return NULL;
19963 }
19964
19965
19966 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19967 PyObject *resultobj = 0;
19968 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19969 int arg2 ;
19970 void *argp1 = 0 ;
19971 int res1 = 0 ;
19972 int val2 ;
19973 int ecode2 = 0 ;
19974 PyObject * obj0 = 0 ;
19975 PyObject * obj1 = 0 ;
19976 char * kwnames[] = {
19977 (char *) "self",(char *) "orient", NULL
19978 };
19979
19980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19982 if (!SWIG_IsOK(res1)) {
19983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19984 }
19985 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19986 ecode2 = SWIG_AsVal_int(obj1, &val2);
19987 if (!SWIG_IsOK(ecode2)) {
19988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19989 }
19990 arg2 = static_cast< int >(val2);
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 (arg1)->SetOrientation(arg2);
19994 wxPyEndAllowThreads(__tstate);
19995 if (PyErr_Occurred()) SWIG_fail;
19996 }
19997 resultobj = SWIG_Py_Void();
19998 return resultobj;
19999 fail:
20000 return NULL;
20001 }
20002
20003
20004 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20005 PyObject *resultobj = 0;
20006 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20007 int arg2 ;
20008 void *argp1 = 0 ;
20009 int res1 = 0 ;
20010 int val2 ;
20011 int ecode2 = 0 ;
20012 PyObject * obj0 = 0 ;
20013 PyObject * obj1 = 0 ;
20014 char * kwnames[] = {
20015 (char *) "self",(char *) "pos", NULL
20016 };
20017
20018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20020 if (!SWIG_IsOK(res1)) {
20021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20022 }
20023 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20024 ecode2 = SWIG_AsVal_int(obj1, &val2);
20025 if (!SWIG_IsOK(ecode2)) {
20026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20027 }
20028 arg2 = static_cast< int >(val2);
20029 {
20030 PyThreadState* __tstate = wxPyBeginAllowThreads();
20031 (arg1)->SetPosition(arg2);
20032 wxPyEndAllowThreads(__tstate);
20033 if (PyErr_Occurred()) SWIG_fail;
20034 }
20035 resultobj = SWIG_Py_Void();
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20043 PyObject *obj;
20044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20045 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20046 return SWIG_Py_Void();
20047 }
20048
20049 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20050 return SWIG_Python_InitShadowInstance(args);
20051 }
20052
20053 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20054 PyObject *resultobj = 0;
20055 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20056 wxMouseEvent *result = 0 ;
20057 int val1 ;
20058 int ecode1 = 0 ;
20059 PyObject * obj0 = 0 ;
20060 char * kwnames[] = {
20061 (char *) "mouseType", NULL
20062 };
20063
20064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20065 if (obj0) {
20066 ecode1 = SWIG_AsVal_int(obj0, &val1);
20067 if (!SWIG_IsOK(ecode1)) {
20068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20069 }
20070 arg1 = static_cast< wxEventType >(val1);
20071 }
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 {
20079 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20080 }
20081 return resultobj;
20082 fail:
20083 return NULL;
20084 }
20085
20086
20087 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20088 PyObject *resultobj = 0;
20089 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20090 bool result;
20091 void *argp1 = 0 ;
20092 int res1 = 0 ;
20093 PyObject *swig_obj[1] ;
20094
20095 if (!args) SWIG_fail;
20096 swig_obj[0] = args;
20097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20098 if (!SWIG_IsOK(res1)) {
20099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20100 }
20101 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20110 }
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20118 PyObject *resultobj = 0;
20119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20120 int arg2 = (int) wxMOUSE_BTN_ANY ;
20121 bool result;
20122 void *argp1 = 0 ;
20123 int res1 = 0 ;
20124 int val2 ;
20125 int ecode2 = 0 ;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 char * kwnames[] = {
20129 (char *) "self",(char *) "but", NULL
20130 };
20131
20132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20134 if (!SWIG_IsOK(res1)) {
20135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20136 }
20137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20138 if (obj1) {
20139 ecode2 = SWIG_AsVal_int(obj1, &val2);
20140 if (!SWIG_IsOK(ecode2)) {
20141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20142 }
20143 arg2 = static_cast< int >(val2);
20144 }
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 {
20152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20153 }
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20161 PyObject *resultobj = 0;
20162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20163 int arg2 = (int) wxMOUSE_BTN_ANY ;
20164 bool result;
20165 void *argp1 = 0 ;
20166 int res1 = 0 ;
20167 int val2 ;
20168 int ecode2 = 0 ;
20169 PyObject * obj0 = 0 ;
20170 PyObject * obj1 = 0 ;
20171 char * kwnames[] = {
20172 (char *) "self",(char *) "but", NULL
20173 };
20174
20175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20177 if (!SWIG_IsOK(res1)) {
20178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20179 }
20180 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20181 if (obj1) {
20182 ecode2 = SWIG_AsVal_int(obj1, &val2);
20183 if (!SWIG_IsOK(ecode2)) {
20184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20185 }
20186 arg2 = static_cast< int >(val2);
20187 }
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 {
20195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20196 }
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20204 PyObject *resultobj = 0;
20205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20206 int arg2 = (int) wxMOUSE_BTN_ANY ;
20207 bool result;
20208 void *argp1 = 0 ;
20209 int res1 = 0 ;
20210 int val2 ;
20211 int ecode2 = 0 ;
20212 PyObject * obj0 = 0 ;
20213 PyObject * obj1 = 0 ;
20214 char * kwnames[] = {
20215 (char *) "self",(char *) "but", NULL
20216 };
20217
20218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20222 }
20223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20224 if (obj1) {
20225 ecode2 = SWIG_AsVal_int(obj1, &val2);
20226 if (!SWIG_IsOK(ecode2)) {
20227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20228 }
20229 arg2 = static_cast< int >(val2);
20230 }
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 {
20238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20239 }
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20247 PyObject *resultobj = 0;
20248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20249 int arg2 ;
20250 bool result;
20251 void *argp1 = 0 ;
20252 int res1 = 0 ;
20253 int val2 ;
20254 int ecode2 = 0 ;
20255 PyObject * obj0 = 0 ;
20256 PyObject * obj1 = 0 ;
20257 char * kwnames[] = {
20258 (char *) "self",(char *) "button", NULL
20259 };
20260
20261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20263 if (!SWIG_IsOK(res1)) {
20264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20265 }
20266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20267 ecode2 = SWIG_AsVal_int(obj1, &val2);
20268 if (!SWIG_IsOK(ecode2)) {
20269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20270 }
20271 arg2 = static_cast< int >(val2);
20272 {
20273 PyThreadState* __tstate = wxPyBeginAllowThreads();
20274 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20275 wxPyEndAllowThreads(__tstate);
20276 if (PyErr_Occurred()) SWIG_fail;
20277 }
20278 {
20279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20280 }
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20288 PyObject *resultobj = 0;
20289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20290 int arg2 ;
20291 bool result;
20292 void *argp1 = 0 ;
20293 int res1 = 0 ;
20294 int val2 ;
20295 int ecode2 = 0 ;
20296 PyObject * obj0 = 0 ;
20297 PyObject * obj1 = 0 ;
20298 char * kwnames[] = {
20299 (char *) "self",(char *) "but", NULL
20300 };
20301
20302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20304 if (!SWIG_IsOK(res1)) {
20305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20306 }
20307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20308 ecode2 = SWIG_AsVal_int(obj1, &val2);
20309 if (!SWIG_IsOK(ecode2)) {
20310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20311 }
20312 arg2 = static_cast< int >(val2);
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20316 wxPyEndAllowThreads(__tstate);
20317 if (PyErr_Occurred()) SWIG_fail;
20318 }
20319 {
20320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20321 }
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20329 PyObject *resultobj = 0;
20330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20331 int result;
20332 void *argp1 = 0 ;
20333 int res1 = 0 ;
20334 PyObject *swig_obj[1] ;
20335
20336 if (!args) SWIG_fail;
20337 swig_obj[0] = args;
20338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20339 if (!SWIG_IsOK(res1)) {
20340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20341 }
20342 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20343 {
20344 PyThreadState* __tstate = wxPyBeginAllowThreads();
20345 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20346 wxPyEndAllowThreads(__tstate);
20347 if (PyErr_Occurred()) SWIG_fail;
20348 }
20349 resultobj = SWIG_From_int(static_cast< int >(result));
20350 return resultobj;
20351 fail:
20352 return NULL;
20353 }
20354
20355
20356 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20357 PyObject *resultobj = 0;
20358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20359 bool result;
20360 void *argp1 = 0 ;
20361 int res1 = 0 ;
20362 PyObject *swig_obj[1] ;
20363
20364 if (!args) SWIG_fail;
20365 swig_obj[0] = args;
20366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20367 if (!SWIG_IsOK(res1)) {
20368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20369 }
20370 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20371 {
20372 PyThreadState* __tstate = wxPyBeginAllowThreads();
20373 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 {
20378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20379 }
20380 return resultobj;
20381 fail:
20382 return NULL;
20383 }
20384
20385
20386 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387 PyObject *resultobj = 0;
20388 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20389 bool result;
20390 void *argp1 = 0 ;
20391 int res1 = 0 ;
20392 PyObject *swig_obj[1] ;
20393
20394 if (!args) SWIG_fail;
20395 swig_obj[0] = args;
20396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20397 if (!SWIG_IsOK(res1)) {
20398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20399 }
20400 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 {
20408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20409 }
20410 return resultobj;
20411 fail:
20412 return NULL;
20413 }
20414
20415
20416 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20417 PyObject *resultobj = 0;
20418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20419 bool result;
20420 void *argp1 = 0 ;
20421 int res1 = 0 ;
20422 PyObject *swig_obj[1] ;
20423
20424 if (!args) SWIG_fail;
20425 swig_obj[0] = args;
20426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20427 if (!SWIG_IsOK(res1)) {
20428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20429 }
20430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20431 {
20432 PyThreadState* __tstate = wxPyBeginAllowThreads();
20433 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 {
20438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20439 }
20440 return resultobj;
20441 fail:
20442 return NULL;
20443 }
20444
20445
20446 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20447 PyObject *resultobj = 0;
20448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20449 bool result;
20450 void *argp1 = 0 ;
20451 int res1 = 0 ;
20452 PyObject *swig_obj[1] ;
20453
20454 if (!args) SWIG_fail;
20455 swig_obj[0] = args;
20456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20457 if (!SWIG_IsOK(res1)) {
20458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20459 }
20460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20461 {
20462 PyThreadState* __tstate = wxPyBeginAllowThreads();
20463 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20464 wxPyEndAllowThreads(__tstate);
20465 if (PyErr_Occurred()) SWIG_fail;
20466 }
20467 {
20468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20469 }
20470 return resultobj;
20471 fail:
20472 return NULL;
20473 }
20474
20475
20476 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20477 PyObject *resultobj = 0;
20478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20479 bool result;
20480 void *argp1 = 0 ;
20481 int res1 = 0 ;
20482 PyObject *swig_obj[1] ;
20483
20484 if (!args) SWIG_fail;
20485 swig_obj[0] = args;
20486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20487 if (!SWIG_IsOK(res1)) {
20488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20489 }
20490 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20491 {
20492 PyThreadState* __tstate = wxPyBeginAllowThreads();
20493 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20494 wxPyEndAllowThreads(__tstate);
20495 if (PyErr_Occurred()) SWIG_fail;
20496 }
20497 {
20498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20499 }
20500 return resultobj;
20501 fail:
20502 return NULL;
20503 }
20504
20505
20506 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20507 PyObject *resultobj = 0;
20508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20509 bool result;
20510 void *argp1 = 0 ;
20511 int res1 = 0 ;
20512 PyObject *swig_obj[1] ;
20513
20514 if (!args) SWIG_fail;
20515 swig_obj[0] = args;
20516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20517 if (!SWIG_IsOK(res1)) {
20518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20519 }
20520 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20521 {
20522 PyThreadState* __tstate = wxPyBeginAllowThreads();
20523 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20524 wxPyEndAllowThreads(__tstate);
20525 if (PyErr_Occurred()) SWIG_fail;
20526 }
20527 {
20528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20529 }
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20537 PyObject *resultobj = 0;
20538 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20539 bool result;
20540 void *argp1 = 0 ;
20541 int res1 = 0 ;
20542 PyObject *swig_obj[1] ;
20543
20544 if (!args) SWIG_fail;
20545 swig_obj[0] = args;
20546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20547 if (!SWIG_IsOK(res1)) {
20548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20549 }
20550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20551 {
20552 PyThreadState* __tstate = wxPyBeginAllowThreads();
20553 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20554 wxPyEndAllowThreads(__tstate);
20555 if (PyErr_Occurred()) SWIG_fail;
20556 }
20557 {
20558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20559 }
20560 return resultobj;
20561 fail:
20562 return NULL;
20563 }
20564
20565
20566 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20567 PyObject *resultobj = 0;
20568 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20569 bool result;
20570 void *argp1 = 0 ;
20571 int res1 = 0 ;
20572 PyObject *swig_obj[1] ;
20573
20574 if (!args) SWIG_fail;
20575 swig_obj[0] = args;
20576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20577 if (!SWIG_IsOK(res1)) {
20578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20579 }
20580 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20581 {
20582 PyThreadState* __tstate = wxPyBeginAllowThreads();
20583 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20584 wxPyEndAllowThreads(__tstate);
20585 if (PyErr_Occurred()) SWIG_fail;
20586 }
20587 {
20588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20589 }
20590 return resultobj;
20591 fail:
20592 return NULL;
20593 }
20594
20595
20596 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20597 PyObject *resultobj = 0;
20598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20599 bool result;
20600 void *argp1 = 0 ;
20601 int res1 = 0 ;
20602 PyObject *swig_obj[1] ;
20603
20604 if (!args) SWIG_fail;
20605 swig_obj[0] = args;
20606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20607 if (!SWIG_IsOK(res1)) {
20608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20609 }
20610 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20614 wxPyEndAllowThreads(__tstate);
20615 if (PyErr_Occurred()) SWIG_fail;
20616 }
20617 {
20618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20619 }
20620 return resultobj;
20621 fail:
20622 return NULL;
20623 }
20624
20625
20626 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20627 PyObject *resultobj = 0;
20628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20629 bool result;
20630 void *argp1 = 0 ;
20631 int res1 = 0 ;
20632 PyObject *swig_obj[1] ;
20633
20634 if (!args) SWIG_fail;
20635 swig_obj[0] = args;
20636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20637 if (!SWIG_IsOK(res1)) {
20638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20639 }
20640 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20641 {
20642 PyThreadState* __tstate = wxPyBeginAllowThreads();
20643 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20644 wxPyEndAllowThreads(__tstate);
20645 if (PyErr_Occurred()) SWIG_fail;
20646 }
20647 {
20648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20649 }
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20657 PyObject *resultobj = 0;
20658 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20659 bool result;
20660 void *argp1 = 0 ;
20661 int res1 = 0 ;
20662 PyObject *swig_obj[1] ;
20663
20664 if (!args) SWIG_fail;
20665 swig_obj[0] = args;
20666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20667 if (!SWIG_IsOK(res1)) {
20668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20669 }
20670 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 {
20678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20679 }
20680 return resultobj;
20681 fail:
20682 return NULL;
20683 }
20684
20685
20686 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20687 PyObject *resultobj = 0;
20688 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20689 bool result;
20690 void *argp1 = 0 ;
20691 int res1 = 0 ;
20692 PyObject *swig_obj[1] ;
20693
20694 if (!args) SWIG_fail;
20695 swig_obj[0] = args;
20696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20697 if (!SWIG_IsOK(res1)) {
20698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20699 }
20700 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 {
20708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20709 }
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20717 PyObject *resultobj = 0;
20718 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20719 bool result;
20720 void *argp1 = 0 ;
20721 int res1 = 0 ;
20722 PyObject *swig_obj[1] ;
20723
20724 if (!args) SWIG_fail;
20725 swig_obj[0] = args;
20726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20727 if (!SWIG_IsOK(res1)) {
20728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20729 }
20730 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 {
20738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20739 }
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20747 PyObject *resultobj = 0;
20748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20749 bool result;
20750 void *argp1 = 0 ;
20751 int res1 = 0 ;
20752 PyObject *swig_obj[1] ;
20753
20754 if (!args) SWIG_fail;
20755 swig_obj[0] = args;
20756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20757 if (!SWIG_IsOK(res1)) {
20758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20759 }
20760 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20761 {
20762 PyThreadState* __tstate = wxPyBeginAllowThreads();
20763 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 {
20768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20769 }
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20777 PyObject *resultobj = 0;
20778 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20779 bool result;
20780 void *argp1 = 0 ;
20781 int res1 = 0 ;
20782 PyObject *swig_obj[1] ;
20783
20784 if (!args) SWIG_fail;
20785 swig_obj[0] = args;
20786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20787 if (!SWIG_IsOK(res1)) {
20788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20789 }
20790 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20791 {
20792 PyThreadState* __tstate = wxPyBeginAllowThreads();
20793 result = (bool)(arg1)->LeftIsDown();
20794 wxPyEndAllowThreads(__tstate);
20795 if (PyErr_Occurred()) SWIG_fail;
20796 }
20797 {
20798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20799 }
20800 return resultobj;
20801 fail:
20802 return NULL;
20803 }
20804
20805
20806 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20807 PyObject *resultobj = 0;
20808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20809 bool result;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 PyObject *swig_obj[1] ;
20813
20814 if (!args) SWIG_fail;
20815 swig_obj[0] = args;
20816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20819 }
20820 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (bool)(arg1)->MiddleIsDown();
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20829 }
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20837 PyObject *resultobj = 0;
20838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20839 bool result;
20840 void *argp1 = 0 ;
20841 int res1 = 0 ;
20842 PyObject *swig_obj[1] ;
20843
20844 if (!args) SWIG_fail;
20845 swig_obj[0] = args;
20846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20847 if (!SWIG_IsOK(res1)) {
20848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20849 }
20850 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = (bool)(arg1)->RightIsDown();
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20859 }
20860 return resultobj;
20861 fail:
20862 return NULL;
20863 }
20864
20865
20866 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20867 PyObject *resultobj = 0;
20868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20869 bool result;
20870 void *argp1 = 0 ;
20871 int res1 = 0 ;
20872 PyObject *swig_obj[1] ;
20873
20874 if (!args) SWIG_fail;
20875 swig_obj[0] = args;
20876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20877 if (!SWIG_IsOK(res1)) {
20878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20879 }
20880 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 {
20888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20889 }
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20897 PyObject *resultobj = 0;
20898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20899 bool result;
20900 void *argp1 = 0 ;
20901 int res1 = 0 ;
20902 PyObject *swig_obj[1] ;
20903
20904 if (!args) SWIG_fail;
20905 swig_obj[0] = args;
20906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20907 if (!SWIG_IsOK(res1)) {
20908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20909 }
20910 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20914 wxPyEndAllowThreads(__tstate);
20915 if (PyErr_Occurred()) SWIG_fail;
20916 }
20917 {
20918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20919 }
20920 return resultobj;
20921 fail:
20922 return NULL;
20923 }
20924
20925
20926 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20927 PyObject *resultobj = 0;
20928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20929 bool result;
20930 void *argp1 = 0 ;
20931 int res1 = 0 ;
20932 PyObject *swig_obj[1] ;
20933
20934 if (!args) SWIG_fail;
20935 swig_obj[0] = args;
20936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20937 if (!SWIG_IsOK(res1)) {
20938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20939 }
20940 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 {
20948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20949 }
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20957 PyObject *resultobj = 0;
20958 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20959 bool result;
20960 void *argp1 = 0 ;
20961 int res1 = 0 ;
20962 PyObject *swig_obj[1] ;
20963
20964 if (!args) SWIG_fail;
20965 swig_obj[0] = args;
20966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20967 if (!SWIG_IsOK(res1)) {
20968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20969 }
20970 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 {
20978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20979 }
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20987 PyObject *resultobj = 0;
20988 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20989 wxPoint result;
20990 void *argp1 = 0 ;
20991 int res1 = 0 ;
20992 PyObject *swig_obj[1] ;
20993
20994 if (!args) SWIG_fail;
20995 swig_obj[0] = args;
20996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20997 if (!SWIG_IsOK(res1)) {
20998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20999 }
21000 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 result = (arg1)->GetPosition();
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21017 long *arg2 = (long *) 0 ;
21018 long *arg3 = (long *) 0 ;
21019 void *argp1 = 0 ;
21020 int res1 = 0 ;
21021 long temp2 ;
21022 int res2 = SWIG_TMPOBJ ;
21023 long temp3 ;
21024 int res3 = SWIG_TMPOBJ ;
21025 PyObject *swig_obj[1] ;
21026
21027 arg2 = &temp2;
21028 arg3 = &temp3;
21029 if (!args) SWIG_fail;
21030 swig_obj[0] = args;
21031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21032 if (!SWIG_IsOK(res1)) {
21033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21034 }
21035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 (arg1)->GetPosition(arg2,arg3);
21039 wxPyEndAllowThreads(__tstate);
21040 if (PyErr_Occurred()) SWIG_fail;
21041 }
21042 resultobj = SWIG_Py_Void();
21043 if (SWIG_IsTmpObj(res2)) {
21044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21045 } else {
21046 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21048 }
21049 if (SWIG_IsTmpObj(res3)) {
21050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21051 } else {
21052 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21054 }
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21062 PyObject *resultobj = 0;
21063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21064 wxDC *arg2 = 0 ;
21065 wxPoint result;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 void *argp2 = 0 ;
21069 int res2 = 0 ;
21070 PyObject * obj0 = 0 ;
21071 PyObject * obj1 = 0 ;
21072 char * kwnames[] = {
21073 (char *) "self",(char *) "dc", NULL
21074 };
21075
21076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21078 if (!SWIG_IsOK(res1)) {
21079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21080 }
21081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21082 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21083 if (!SWIG_IsOK(res2)) {
21084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21085 }
21086 if (!argp2) {
21087 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21088 }
21089 arg2 = reinterpret_cast< wxDC * >(argp2);
21090 {
21091 PyThreadState* __tstate = wxPyBeginAllowThreads();
21092 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21093 wxPyEndAllowThreads(__tstate);
21094 if (PyErr_Occurred()) SWIG_fail;
21095 }
21096 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21097 return resultobj;
21098 fail:
21099 return NULL;
21100 }
21101
21102
21103 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21104 PyObject *resultobj = 0;
21105 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21106 int result;
21107 void *argp1 = 0 ;
21108 int res1 = 0 ;
21109 PyObject *swig_obj[1] ;
21110
21111 if (!args) SWIG_fail;
21112 swig_obj[0] = args;
21113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21116 }
21117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 result = (int)((wxMouseEvent const *)arg1)->GetX();
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 resultobj = SWIG_From_int(static_cast< int >(result));
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21132 PyObject *resultobj = 0;
21133 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21134 int result;
21135 void *argp1 = 0 ;
21136 int res1 = 0 ;
21137 PyObject *swig_obj[1] ;
21138
21139 if (!args) SWIG_fail;
21140 swig_obj[0] = args;
21141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21144 }
21145 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = (int)((wxMouseEvent const *)arg1)->GetY();
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 resultobj = SWIG_From_int(static_cast< int >(result));
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21160 PyObject *resultobj = 0;
21161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21162 int result;
21163 void *argp1 = 0 ;
21164 int res1 = 0 ;
21165 PyObject *swig_obj[1] ;
21166
21167 if (!args) SWIG_fail;
21168 swig_obj[0] = args;
21169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21172 }
21173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21177 wxPyEndAllowThreads(__tstate);
21178 if (PyErr_Occurred()) SWIG_fail;
21179 }
21180 resultobj = SWIG_From_int(static_cast< int >(result));
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21188 PyObject *resultobj = 0;
21189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21190 int result;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 PyObject *swig_obj[1] ;
21194
21195 if (!args) SWIG_fail;
21196 swig_obj[0] = args;
21197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21200 }
21201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 resultobj = SWIG_From_int(static_cast< int >(result));
21209 return resultobj;
21210 fail:
21211 return NULL;
21212 }
21213
21214
21215 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21216 PyObject *resultobj = 0;
21217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21218 int result;
21219 void *argp1 = 0 ;
21220 int res1 = 0 ;
21221 PyObject *swig_obj[1] ;
21222
21223 if (!args) SWIG_fail;
21224 swig_obj[0] = args;
21225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21226 if (!SWIG_IsOK(res1)) {
21227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21228 }
21229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21230 {
21231 PyThreadState* __tstate = wxPyBeginAllowThreads();
21232 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21233 wxPyEndAllowThreads(__tstate);
21234 if (PyErr_Occurred()) SWIG_fail;
21235 }
21236 resultobj = SWIG_From_int(static_cast< int >(result));
21237 return resultobj;
21238 fail:
21239 return NULL;
21240 }
21241
21242
21243 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21244 PyObject *resultobj = 0;
21245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21246 bool result;
21247 void *argp1 = 0 ;
21248 int res1 = 0 ;
21249 PyObject *swig_obj[1] ;
21250
21251 if (!args) SWIG_fail;
21252 swig_obj[0] = args;
21253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21254 if (!SWIG_IsOK(res1)) {
21255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21256 }
21257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21258 {
21259 PyThreadState* __tstate = wxPyBeginAllowThreads();
21260 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21261 wxPyEndAllowThreads(__tstate);
21262 if (PyErr_Occurred()) SWIG_fail;
21263 }
21264 {
21265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21266 }
21267 return resultobj;
21268 fail:
21269 return NULL;
21270 }
21271
21272
21273 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21274 PyObject *resultobj = 0;
21275 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21276 int arg2 ;
21277 void *argp1 = 0 ;
21278 int res1 = 0 ;
21279 int val2 ;
21280 int ecode2 = 0 ;
21281 PyObject *swig_obj[2] ;
21282
21283 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21285 if (!SWIG_IsOK(res1)) {
21286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21287 }
21288 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21289 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21290 if (!SWIG_IsOK(ecode2)) {
21291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21292 }
21293 arg2 = static_cast< int >(val2);
21294 if (arg1) (arg1)->m_x = arg2;
21295
21296 resultobj = SWIG_Py_Void();
21297 return resultobj;
21298 fail:
21299 return NULL;
21300 }
21301
21302
21303 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21304 PyObject *resultobj = 0;
21305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21306 int result;
21307 void *argp1 = 0 ;
21308 int res1 = 0 ;
21309 PyObject *swig_obj[1] ;
21310
21311 if (!args) SWIG_fail;
21312 swig_obj[0] = args;
21313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21314 if (!SWIG_IsOK(res1)) {
21315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21316 }
21317 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21318 result = (int) ((arg1)->m_x);
21319 resultobj = SWIG_From_int(static_cast< int >(result));
21320 return resultobj;
21321 fail:
21322 return NULL;
21323 }
21324
21325
21326 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21327 PyObject *resultobj = 0;
21328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21329 int arg2 ;
21330 void *argp1 = 0 ;
21331 int res1 = 0 ;
21332 int val2 ;
21333 int ecode2 = 0 ;
21334 PyObject *swig_obj[2] ;
21335
21336 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21338 if (!SWIG_IsOK(res1)) {
21339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21340 }
21341 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21342 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21343 if (!SWIG_IsOK(ecode2)) {
21344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21345 }
21346 arg2 = static_cast< int >(val2);
21347 if (arg1) (arg1)->m_y = arg2;
21348
21349 resultobj = SWIG_Py_Void();
21350 return resultobj;
21351 fail:
21352 return NULL;
21353 }
21354
21355
21356 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21357 PyObject *resultobj = 0;
21358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21359 int result;
21360 void *argp1 = 0 ;
21361 int res1 = 0 ;
21362 PyObject *swig_obj[1] ;
21363
21364 if (!args) SWIG_fail;
21365 swig_obj[0] = args;
21366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21367 if (!SWIG_IsOK(res1)) {
21368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21369 }
21370 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21371 result = (int) ((arg1)->m_y);
21372 resultobj = SWIG_From_int(static_cast< int >(result));
21373 return resultobj;
21374 fail:
21375 return NULL;
21376 }
21377
21378
21379 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21380 PyObject *resultobj = 0;
21381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21382 bool arg2 ;
21383 void *argp1 = 0 ;
21384 int res1 = 0 ;
21385 bool val2 ;
21386 int ecode2 = 0 ;
21387 PyObject *swig_obj[2] ;
21388
21389 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21391 if (!SWIG_IsOK(res1)) {
21392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21393 }
21394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21395 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21396 if (!SWIG_IsOK(ecode2)) {
21397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21398 }
21399 arg2 = static_cast< bool >(val2);
21400 if (arg1) (arg1)->m_leftDown = arg2;
21401
21402 resultobj = SWIG_Py_Void();
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21410 PyObject *resultobj = 0;
21411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21412 bool result;
21413 void *argp1 = 0 ;
21414 int res1 = 0 ;
21415 PyObject *swig_obj[1] ;
21416
21417 if (!args) SWIG_fail;
21418 swig_obj[0] = args;
21419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21420 if (!SWIG_IsOK(res1)) {
21421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21422 }
21423 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21424 result = (bool) ((arg1)->m_leftDown);
21425 {
21426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21427 }
21428 return resultobj;
21429 fail:
21430 return NULL;
21431 }
21432
21433
21434 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21435 PyObject *resultobj = 0;
21436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21437 bool arg2 ;
21438 void *argp1 = 0 ;
21439 int res1 = 0 ;
21440 bool val2 ;
21441 int ecode2 = 0 ;
21442 PyObject *swig_obj[2] ;
21443
21444 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21446 if (!SWIG_IsOK(res1)) {
21447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21448 }
21449 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21450 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21451 if (!SWIG_IsOK(ecode2)) {
21452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21453 }
21454 arg2 = static_cast< bool >(val2);
21455 if (arg1) (arg1)->m_middleDown = arg2;
21456
21457 resultobj = SWIG_Py_Void();
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21465 PyObject *resultobj = 0;
21466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21467 bool result;
21468 void *argp1 = 0 ;
21469 int res1 = 0 ;
21470 PyObject *swig_obj[1] ;
21471
21472 if (!args) SWIG_fail;
21473 swig_obj[0] = args;
21474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21475 if (!SWIG_IsOK(res1)) {
21476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21477 }
21478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21479 result = (bool) ((arg1)->m_middleDown);
21480 {
21481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21482 }
21483 return resultobj;
21484 fail:
21485 return NULL;
21486 }
21487
21488
21489 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21490 PyObject *resultobj = 0;
21491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21492 bool arg2 ;
21493 void *argp1 = 0 ;
21494 int res1 = 0 ;
21495 bool val2 ;
21496 int ecode2 = 0 ;
21497 PyObject *swig_obj[2] ;
21498
21499 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21501 if (!SWIG_IsOK(res1)) {
21502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21503 }
21504 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21505 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21506 if (!SWIG_IsOK(ecode2)) {
21507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21508 }
21509 arg2 = static_cast< bool >(val2);
21510 if (arg1) (arg1)->m_rightDown = arg2;
21511
21512 resultobj = SWIG_Py_Void();
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21520 PyObject *resultobj = 0;
21521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21522 bool result;
21523 void *argp1 = 0 ;
21524 int res1 = 0 ;
21525 PyObject *swig_obj[1] ;
21526
21527 if (!args) SWIG_fail;
21528 swig_obj[0] = args;
21529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21530 if (!SWIG_IsOK(res1)) {
21531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21532 }
21533 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21534 result = (bool) ((arg1)->m_rightDown);
21535 {
21536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21537 }
21538 return resultobj;
21539 fail:
21540 return NULL;
21541 }
21542
21543
21544 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21545 PyObject *resultobj = 0;
21546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21547 bool arg2 ;
21548 void *argp1 = 0 ;
21549 int res1 = 0 ;
21550 bool val2 ;
21551 int ecode2 = 0 ;
21552 PyObject *swig_obj[2] ;
21553
21554 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21556 if (!SWIG_IsOK(res1)) {
21557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21558 }
21559 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21560 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21561 if (!SWIG_IsOK(ecode2)) {
21562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21563 }
21564 arg2 = static_cast< bool >(val2);
21565 if (arg1) (arg1)->m_controlDown = arg2;
21566
21567 resultobj = SWIG_Py_Void();
21568 return resultobj;
21569 fail:
21570 return NULL;
21571 }
21572
21573
21574 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21575 PyObject *resultobj = 0;
21576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21577 bool result;
21578 void *argp1 = 0 ;
21579 int res1 = 0 ;
21580 PyObject *swig_obj[1] ;
21581
21582 if (!args) SWIG_fail;
21583 swig_obj[0] = args;
21584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21585 if (!SWIG_IsOK(res1)) {
21586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21587 }
21588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21589 result = (bool) ((arg1)->m_controlDown);
21590 {
21591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21592 }
21593 return resultobj;
21594 fail:
21595 return NULL;
21596 }
21597
21598
21599 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21600 PyObject *resultobj = 0;
21601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21602 bool arg2 ;
21603 void *argp1 = 0 ;
21604 int res1 = 0 ;
21605 bool val2 ;
21606 int ecode2 = 0 ;
21607 PyObject *swig_obj[2] ;
21608
21609 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21611 if (!SWIG_IsOK(res1)) {
21612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21613 }
21614 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21615 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21616 if (!SWIG_IsOK(ecode2)) {
21617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21618 }
21619 arg2 = static_cast< bool >(val2);
21620 if (arg1) (arg1)->m_shiftDown = arg2;
21621
21622 resultobj = SWIG_Py_Void();
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21630 PyObject *resultobj = 0;
21631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21632 bool result;
21633 void *argp1 = 0 ;
21634 int res1 = 0 ;
21635 PyObject *swig_obj[1] ;
21636
21637 if (!args) SWIG_fail;
21638 swig_obj[0] = args;
21639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21640 if (!SWIG_IsOK(res1)) {
21641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21642 }
21643 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21644 result = (bool) ((arg1)->m_shiftDown);
21645 {
21646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21647 }
21648 return resultobj;
21649 fail:
21650 return NULL;
21651 }
21652
21653
21654 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21655 PyObject *resultobj = 0;
21656 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21657 bool arg2 ;
21658 void *argp1 = 0 ;
21659 int res1 = 0 ;
21660 bool val2 ;
21661 int ecode2 = 0 ;
21662 PyObject *swig_obj[2] ;
21663
21664 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21666 if (!SWIG_IsOK(res1)) {
21667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21668 }
21669 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21670 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21671 if (!SWIG_IsOK(ecode2)) {
21672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21673 }
21674 arg2 = static_cast< bool >(val2);
21675 if (arg1) (arg1)->m_altDown = arg2;
21676
21677 resultobj = SWIG_Py_Void();
21678 return resultobj;
21679 fail:
21680 return NULL;
21681 }
21682
21683
21684 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21685 PyObject *resultobj = 0;
21686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21687 bool result;
21688 void *argp1 = 0 ;
21689 int res1 = 0 ;
21690 PyObject *swig_obj[1] ;
21691
21692 if (!args) SWIG_fail;
21693 swig_obj[0] = args;
21694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21695 if (!SWIG_IsOK(res1)) {
21696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21697 }
21698 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21699 result = (bool) ((arg1)->m_altDown);
21700 {
21701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21702 }
21703 return resultobj;
21704 fail:
21705 return NULL;
21706 }
21707
21708
21709 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21710 PyObject *resultobj = 0;
21711 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21712 bool arg2 ;
21713 void *argp1 = 0 ;
21714 int res1 = 0 ;
21715 bool val2 ;
21716 int ecode2 = 0 ;
21717 PyObject *swig_obj[2] ;
21718
21719 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21723 }
21724 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21725 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21726 if (!SWIG_IsOK(ecode2)) {
21727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21728 }
21729 arg2 = static_cast< bool >(val2);
21730 if (arg1) (arg1)->m_metaDown = arg2;
21731
21732 resultobj = SWIG_Py_Void();
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 PyObject *resultobj = 0;
21741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21742 bool result;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 PyObject *swig_obj[1] ;
21746
21747 if (!args) SWIG_fail;
21748 swig_obj[0] = args;
21749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21750 if (!SWIG_IsOK(res1)) {
21751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21752 }
21753 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21754 result = (bool) ((arg1)->m_metaDown);
21755 {
21756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21757 }
21758 return resultobj;
21759 fail:
21760 return NULL;
21761 }
21762
21763
21764 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21765 PyObject *resultobj = 0;
21766 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21767 int arg2 ;
21768 void *argp1 = 0 ;
21769 int res1 = 0 ;
21770 int val2 ;
21771 int ecode2 = 0 ;
21772 PyObject *swig_obj[2] ;
21773
21774 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21776 if (!SWIG_IsOK(res1)) {
21777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21778 }
21779 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21780 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21781 if (!SWIG_IsOK(ecode2)) {
21782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21783 }
21784 arg2 = static_cast< int >(val2);
21785 if (arg1) (arg1)->m_wheelRotation = arg2;
21786
21787 resultobj = SWIG_Py_Void();
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21795 PyObject *resultobj = 0;
21796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21797 int result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 PyObject *swig_obj[1] ;
21801
21802 if (!args) SWIG_fail;
21803 swig_obj[0] = args;
21804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21805 if (!SWIG_IsOK(res1)) {
21806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21807 }
21808 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21809 result = (int) ((arg1)->m_wheelRotation);
21810 resultobj = SWIG_From_int(static_cast< int >(result));
21811 return resultobj;
21812 fail:
21813 return NULL;
21814 }
21815
21816
21817 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21818 PyObject *resultobj = 0;
21819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21820 int arg2 ;
21821 void *argp1 = 0 ;
21822 int res1 = 0 ;
21823 int val2 ;
21824 int ecode2 = 0 ;
21825 PyObject *swig_obj[2] ;
21826
21827 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21829 if (!SWIG_IsOK(res1)) {
21830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21831 }
21832 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21833 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21834 if (!SWIG_IsOK(ecode2)) {
21835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21836 }
21837 arg2 = static_cast< int >(val2);
21838 if (arg1) (arg1)->m_wheelDelta = arg2;
21839
21840 resultobj = SWIG_Py_Void();
21841 return resultobj;
21842 fail:
21843 return NULL;
21844 }
21845
21846
21847 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21848 PyObject *resultobj = 0;
21849 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21850 int result;
21851 void *argp1 = 0 ;
21852 int res1 = 0 ;
21853 PyObject *swig_obj[1] ;
21854
21855 if (!args) SWIG_fail;
21856 swig_obj[0] = args;
21857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21858 if (!SWIG_IsOK(res1)) {
21859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21860 }
21861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21862 result = (int) ((arg1)->m_wheelDelta);
21863 resultobj = SWIG_From_int(static_cast< int >(result));
21864 return resultobj;
21865 fail:
21866 return NULL;
21867 }
21868
21869
21870 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21871 PyObject *resultobj = 0;
21872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21873 int arg2 ;
21874 void *argp1 = 0 ;
21875 int res1 = 0 ;
21876 int val2 ;
21877 int ecode2 = 0 ;
21878 PyObject *swig_obj[2] ;
21879
21880 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21882 if (!SWIG_IsOK(res1)) {
21883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21884 }
21885 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21886 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21887 if (!SWIG_IsOK(ecode2)) {
21888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21889 }
21890 arg2 = static_cast< int >(val2);
21891 if (arg1) (arg1)->m_linesPerAction = arg2;
21892
21893 resultobj = SWIG_Py_Void();
21894 return resultobj;
21895 fail:
21896 return NULL;
21897 }
21898
21899
21900 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21901 PyObject *resultobj = 0;
21902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21903 int result;
21904 void *argp1 = 0 ;
21905 int res1 = 0 ;
21906 PyObject *swig_obj[1] ;
21907
21908 if (!args) SWIG_fail;
21909 swig_obj[0] = args;
21910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21911 if (!SWIG_IsOK(res1)) {
21912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21913 }
21914 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21915 result = (int) ((arg1)->m_linesPerAction);
21916 resultobj = SWIG_From_int(static_cast< int >(result));
21917 return resultobj;
21918 fail:
21919 return NULL;
21920 }
21921
21922
21923 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21924 PyObject *obj;
21925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21926 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21927 return SWIG_Py_Void();
21928 }
21929
21930 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21931 return SWIG_Python_InitShadowInstance(args);
21932 }
21933
21934 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21935 PyObject *resultobj = 0;
21936 int arg1 = (int) 0 ;
21937 int arg2 = (int) 0 ;
21938 wxSetCursorEvent *result = 0 ;
21939 int val1 ;
21940 int ecode1 = 0 ;
21941 int val2 ;
21942 int ecode2 = 0 ;
21943 PyObject * obj0 = 0 ;
21944 PyObject * obj1 = 0 ;
21945 char * kwnames[] = {
21946 (char *) "x",(char *) "y", NULL
21947 };
21948
21949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21950 if (obj0) {
21951 ecode1 = SWIG_AsVal_int(obj0, &val1);
21952 if (!SWIG_IsOK(ecode1)) {
21953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21954 }
21955 arg1 = static_cast< int >(val1);
21956 }
21957 if (obj1) {
21958 ecode2 = SWIG_AsVal_int(obj1, &val2);
21959 if (!SWIG_IsOK(ecode2)) {
21960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21961 }
21962 arg2 = static_cast< int >(val2);
21963 }
21964 {
21965 PyThreadState* __tstate = wxPyBeginAllowThreads();
21966 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21967 wxPyEndAllowThreads(__tstate);
21968 if (PyErr_Occurred()) SWIG_fail;
21969 }
21970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21971 return resultobj;
21972 fail:
21973 return NULL;
21974 }
21975
21976
21977 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21978 PyObject *resultobj = 0;
21979 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21980 int result;
21981 void *argp1 = 0 ;
21982 int res1 = 0 ;
21983 PyObject *swig_obj[1] ;
21984
21985 if (!args) SWIG_fail;
21986 swig_obj[0] = args;
21987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21988 if (!SWIG_IsOK(res1)) {
21989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21990 }
21991 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21992 {
21993 PyThreadState* __tstate = wxPyBeginAllowThreads();
21994 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21995 wxPyEndAllowThreads(__tstate);
21996 if (PyErr_Occurred()) SWIG_fail;
21997 }
21998 resultobj = SWIG_From_int(static_cast< int >(result));
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22006 PyObject *resultobj = 0;
22007 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22008 int result;
22009 void *argp1 = 0 ;
22010 int res1 = 0 ;
22011 PyObject *swig_obj[1] ;
22012
22013 if (!args) SWIG_fail;
22014 swig_obj[0] = args;
22015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22016 if (!SWIG_IsOK(res1)) {
22017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22018 }
22019 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22020 {
22021 PyThreadState* __tstate = wxPyBeginAllowThreads();
22022 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 resultobj = SWIG_From_int(static_cast< int >(result));
22027 return resultobj;
22028 fail:
22029 return NULL;
22030 }
22031
22032
22033 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22034 PyObject *resultobj = 0;
22035 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22036 wxCursor *arg2 = 0 ;
22037 void *argp1 = 0 ;
22038 int res1 = 0 ;
22039 void *argp2 = 0 ;
22040 int res2 = 0 ;
22041 PyObject * obj0 = 0 ;
22042 PyObject * obj1 = 0 ;
22043 char * kwnames[] = {
22044 (char *) "self",(char *) "cursor", NULL
22045 };
22046
22047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22049 if (!SWIG_IsOK(res1)) {
22050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22051 }
22052 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22054 if (!SWIG_IsOK(res2)) {
22055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22056 }
22057 if (!argp2) {
22058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22059 }
22060 arg2 = reinterpret_cast< wxCursor * >(argp2);
22061 {
22062 PyThreadState* __tstate = wxPyBeginAllowThreads();
22063 (arg1)->SetCursor((wxCursor const &)*arg2);
22064 wxPyEndAllowThreads(__tstate);
22065 if (PyErr_Occurred()) SWIG_fail;
22066 }
22067 resultobj = SWIG_Py_Void();
22068 return resultobj;
22069 fail:
22070 return NULL;
22071 }
22072
22073
22074 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22075 PyObject *resultobj = 0;
22076 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22077 wxCursor *result = 0 ;
22078 void *argp1 = 0 ;
22079 int res1 = 0 ;
22080 PyObject *swig_obj[1] ;
22081
22082 if (!args) SWIG_fail;
22083 swig_obj[0] = args;
22084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22085 if (!SWIG_IsOK(res1)) {
22086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22087 }
22088 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22089 {
22090 PyThreadState* __tstate = wxPyBeginAllowThreads();
22091 {
22092 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22093 result = (wxCursor *) &_result_ref;
22094 }
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 {
22099 wxCursor* resultptr = new wxCursor(*result);
22100 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22101 }
22102 return resultobj;
22103 fail:
22104 return NULL;
22105 }
22106
22107
22108 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22109 PyObject *resultobj = 0;
22110 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22111 bool result;
22112 void *argp1 = 0 ;
22113 int res1 = 0 ;
22114 PyObject *swig_obj[1] ;
22115
22116 if (!args) SWIG_fail;
22117 swig_obj[0] = args;
22118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22119 if (!SWIG_IsOK(res1)) {
22120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22121 }
22122 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 {
22130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22131 }
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22139 PyObject *obj;
22140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22141 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22142 return SWIG_Py_Void();
22143 }
22144
22145 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22146 return SWIG_Python_InitShadowInstance(args);
22147 }
22148
22149 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22150 PyObject *resultobj = 0;
22151 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22152 wxKeyEvent *result = 0 ;
22153 int val1 ;
22154 int ecode1 = 0 ;
22155 PyObject * obj0 = 0 ;
22156 char * kwnames[] = {
22157 (char *) "eventType", NULL
22158 };
22159
22160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22161 if (obj0) {
22162 ecode1 = SWIG_AsVal_int(obj0, &val1);
22163 if (!SWIG_IsOK(ecode1)) {
22164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22165 }
22166 arg1 = static_cast< wxEventType >(val1);
22167 }
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *resultobj = 0;
22183 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22184 int result;
22185 void *argp1 = 0 ;
22186 int res1 = 0 ;
22187 PyObject *swig_obj[1] ;
22188
22189 if (!args) SWIG_fail;
22190 swig_obj[0] = args;
22191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22192 if (!SWIG_IsOK(res1)) {
22193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22194 }
22195 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 resultobj = SWIG_From_int(static_cast< int >(result));
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22210 PyObject *resultobj = 0;
22211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22212 bool result;
22213 void *argp1 = 0 ;
22214 int res1 = 0 ;
22215 PyObject *swig_obj[1] ;
22216
22217 if (!args) SWIG_fail;
22218 swig_obj[0] = args;
22219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22220 if (!SWIG_IsOK(res1)) {
22221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22222 }
22223 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22224 {
22225 PyThreadState* __tstate = wxPyBeginAllowThreads();
22226 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22227 wxPyEndAllowThreads(__tstate);
22228 if (PyErr_Occurred()) SWIG_fail;
22229 }
22230 {
22231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22232 }
22233 return resultobj;
22234 fail:
22235 return NULL;
22236 }
22237
22238
22239 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22240 PyObject *resultobj = 0;
22241 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22242 bool result;
22243 void *argp1 = 0 ;
22244 int res1 = 0 ;
22245 PyObject *swig_obj[1] ;
22246
22247 if (!args) SWIG_fail;
22248 swig_obj[0] = args;
22249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22250 if (!SWIG_IsOK(res1)) {
22251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22252 }
22253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22254 {
22255 PyThreadState* __tstate = wxPyBeginAllowThreads();
22256 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 {
22261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22262 }
22263 return resultobj;
22264 fail:
22265 return NULL;
22266 }
22267
22268
22269 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22270 PyObject *resultobj = 0;
22271 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22272 bool result;
22273 void *argp1 = 0 ;
22274 int res1 = 0 ;
22275 PyObject *swig_obj[1] ;
22276
22277 if (!args) SWIG_fail;
22278 swig_obj[0] = args;
22279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22280 if (!SWIG_IsOK(res1)) {
22281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22282 }
22283 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 {
22291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22300 PyObject *resultobj = 0;
22301 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22302 bool result;
22303 void *argp1 = 0 ;
22304 int res1 = 0 ;
22305 PyObject *swig_obj[1] ;
22306
22307 if (!args) SWIG_fail;
22308 swig_obj[0] = args;
22309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22310 if (!SWIG_IsOK(res1)) {
22311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22312 }
22313 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22314 {
22315 PyThreadState* __tstate = wxPyBeginAllowThreads();
22316 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22317 wxPyEndAllowThreads(__tstate);
22318 if (PyErr_Occurred()) SWIG_fail;
22319 }
22320 {
22321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22322 }
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22330 PyObject *resultobj = 0;
22331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22332 bool result;
22333 void *argp1 = 0 ;
22334 int res1 = 0 ;
22335 PyObject *swig_obj[1] ;
22336
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22342 }
22343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 {
22351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22352 }
22353 return resultobj;
22354 fail:
22355 return NULL;
22356 }
22357
22358
22359 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22360 PyObject *resultobj = 0;
22361 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22362 bool result;
22363 void *argp1 = 0 ;
22364 int res1 = 0 ;
22365 PyObject *swig_obj[1] ;
22366
22367 if (!args) SWIG_fail;
22368 swig_obj[0] = args;
22369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22370 if (!SWIG_IsOK(res1)) {
22371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22372 }
22373 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 {
22381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22382 }
22383 return resultobj;
22384 fail:
22385 return NULL;
22386 }
22387
22388
22389 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22390 PyObject *resultobj = 0;
22391 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22392 int result;
22393 void *argp1 = 0 ;
22394 int res1 = 0 ;
22395 PyObject *swig_obj[1] ;
22396
22397 if (!args) SWIG_fail;
22398 swig_obj[0] = args;
22399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22400 if (!SWIG_IsOK(res1)) {
22401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22402 }
22403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22404 {
22405 PyThreadState* __tstate = wxPyBeginAllowThreads();
22406 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22407 wxPyEndAllowThreads(__tstate);
22408 if (PyErr_Occurred()) SWIG_fail;
22409 }
22410 resultobj = SWIG_From_int(static_cast< int >(result));
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22418 PyObject *resultobj = 0;
22419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22420 int result;
22421 void *argp1 = 0 ;
22422 int res1 = 0 ;
22423 PyObject *swig_obj[1] ;
22424
22425 if (!args) SWIG_fail;
22426 swig_obj[0] = args;
22427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22428 if (!SWIG_IsOK(res1)) {
22429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22430 }
22431 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22432 {
22433 PyThreadState* __tstate = wxPyBeginAllowThreads();
22434 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22435 wxPyEndAllowThreads(__tstate);
22436 if (PyErr_Occurred()) SWIG_fail;
22437 }
22438 resultobj = SWIG_From_int(static_cast< int >(result));
22439 return resultobj;
22440 fail:
22441 return NULL;
22442 }
22443
22444
22445 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22446 PyObject *resultobj = 0;
22447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22448 int arg2 ;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 int val2 ;
22452 int ecode2 = 0 ;
22453 PyObject * obj0 = 0 ;
22454 PyObject * obj1 = 0 ;
22455 char * kwnames[] = {
22456 (char *) "self",(char *) "uniChar", NULL
22457 };
22458
22459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22461 if (!SWIG_IsOK(res1)) {
22462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22463 }
22464 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22465 ecode2 = SWIG_AsVal_int(obj1, &val2);
22466 if (!SWIG_IsOK(ecode2)) {
22467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22468 }
22469 arg2 = static_cast< int >(val2);
22470 {
22471 PyThreadState* __tstate = wxPyBeginAllowThreads();
22472 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22473 wxPyEndAllowThreads(__tstate);
22474 if (PyErr_Occurred()) SWIG_fail;
22475 }
22476 resultobj = SWIG_Py_Void();
22477 return resultobj;
22478 fail:
22479 return NULL;
22480 }
22481
22482
22483 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22484 PyObject *resultobj = 0;
22485 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22486 unsigned int result;
22487 void *argp1 = 0 ;
22488 int res1 = 0 ;
22489 PyObject *swig_obj[1] ;
22490
22491 if (!args) SWIG_fail;
22492 swig_obj[0] = args;
22493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22494 if (!SWIG_IsOK(res1)) {
22495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22496 }
22497 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22498 {
22499 PyThreadState* __tstate = wxPyBeginAllowThreads();
22500 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22501 wxPyEndAllowThreads(__tstate);
22502 if (PyErr_Occurred()) SWIG_fail;
22503 }
22504 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22505 return resultobj;
22506 fail:
22507 return NULL;
22508 }
22509
22510
22511 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22512 PyObject *resultobj = 0;
22513 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22514 unsigned int result;
22515 void *argp1 = 0 ;
22516 int res1 = 0 ;
22517 PyObject *swig_obj[1] ;
22518
22519 if (!args) SWIG_fail;
22520 swig_obj[0] = args;
22521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22522 if (!SWIG_IsOK(res1)) {
22523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22524 }
22525 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22529 wxPyEndAllowThreads(__tstate);
22530 if (PyErr_Occurred()) SWIG_fail;
22531 }
22532 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22533 return resultobj;
22534 fail:
22535 return NULL;
22536 }
22537
22538
22539 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22540 PyObject *resultobj = 0;
22541 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22542 wxPoint result;
22543 void *argp1 = 0 ;
22544 int res1 = 0 ;
22545 PyObject *swig_obj[1] ;
22546
22547 if (!args) SWIG_fail;
22548 swig_obj[0] = args;
22549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22550 if (!SWIG_IsOK(res1)) {
22551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22552 }
22553 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 result = (arg1)->GetPosition();
22557 wxPyEndAllowThreads(__tstate);
22558 if (PyErr_Occurred()) SWIG_fail;
22559 }
22560 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22568 PyObject *resultobj = 0;
22569 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22570 long *arg2 = (long *) 0 ;
22571 long *arg3 = (long *) 0 ;
22572 void *argp1 = 0 ;
22573 int res1 = 0 ;
22574 long temp2 ;
22575 int res2 = SWIG_TMPOBJ ;
22576 long temp3 ;
22577 int res3 = SWIG_TMPOBJ ;
22578 PyObject *swig_obj[1] ;
22579
22580 arg2 = &temp2;
22581 arg3 = &temp3;
22582 if (!args) SWIG_fail;
22583 swig_obj[0] = args;
22584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22585 if (!SWIG_IsOK(res1)) {
22586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22587 }
22588 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22589 {
22590 PyThreadState* __tstate = wxPyBeginAllowThreads();
22591 (arg1)->GetPosition(arg2,arg3);
22592 wxPyEndAllowThreads(__tstate);
22593 if (PyErr_Occurred()) SWIG_fail;
22594 }
22595 resultobj = SWIG_Py_Void();
22596 if (SWIG_IsTmpObj(res2)) {
22597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22598 } else {
22599 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22601 }
22602 if (SWIG_IsTmpObj(res3)) {
22603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22604 } else {
22605 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22607 }
22608 return resultobj;
22609 fail:
22610 return NULL;
22611 }
22612
22613
22614 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615 PyObject *resultobj = 0;
22616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22617 int result;
22618 void *argp1 = 0 ;
22619 int res1 = 0 ;
22620 PyObject *swig_obj[1] ;
22621
22622 if (!args) SWIG_fail;
22623 swig_obj[0] = args;
22624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22625 if (!SWIG_IsOK(res1)) {
22626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22627 }
22628 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22629 {
22630 PyThreadState* __tstate = wxPyBeginAllowThreads();
22631 result = (int)((wxKeyEvent const *)arg1)->GetX();
22632 wxPyEndAllowThreads(__tstate);
22633 if (PyErr_Occurred()) SWIG_fail;
22634 }
22635 resultobj = SWIG_From_int(static_cast< int >(result));
22636 return resultobj;
22637 fail:
22638 return NULL;
22639 }
22640
22641
22642 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22643 PyObject *resultobj = 0;
22644 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22645 int result;
22646 void *argp1 = 0 ;
22647 int res1 = 0 ;
22648 PyObject *swig_obj[1] ;
22649
22650 if (!args) SWIG_fail;
22651 swig_obj[0] = args;
22652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22653 if (!SWIG_IsOK(res1)) {
22654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22655 }
22656 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22657 {
22658 PyThreadState* __tstate = wxPyBeginAllowThreads();
22659 result = (int)((wxKeyEvent const *)arg1)->GetY();
22660 wxPyEndAllowThreads(__tstate);
22661 if (PyErr_Occurred()) SWIG_fail;
22662 }
22663 resultobj = SWIG_From_int(static_cast< int >(result));
22664 return resultobj;
22665 fail:
22666 return NULL;
22667 }
22668
22669
22670 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22671 PyObject *resultobj = 0;
22672 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22673 int arg2 ;
22674 void *argp1 = 0 ;
22675 int res1 = 0 ;
22676 int val2 ;
22677 int ecode2 = 0 ;
22678 PyObject *swig_obj[2] ;
22679
22680 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22682 if (!SWIG_IsOK(res1)) {
22683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22684 }
22685 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22686 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22687 if (!SWIG_IsOK(ecode2)) {
22688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22689 }
22690 arg2 = static_cast< int >(val2);
22691 if (arg1) (arg1)->m_x = arg2;
22692
22693 resultobj = SWIG_Py_Void();
22694 return resultobj;
22695 fail:
22696 return NULL;
22697 }
22698
22699
22700 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22701 PyObject *resultobj = 0;
22702 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22703 int result;
22704 void *argp1 = 0 ;
22705 int res1 = 0 ;
22706 PyObject *swig_obj[1] ;
22707
22708 if (!args) SWIG_fail;
22709 swig_obj[0] = args;
22710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22711 if (!SWIG_IsOK(res1)) {
22712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22713 }
22714 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22715 result = (int) ((arg1)->m_x);
22716 resultobj = SWIG_From_int(static_cast< int >(result));
22717 return resultobj;
22718 fail:
22719 return NULL;
22720 }
22721
22722
22723 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22724 PyObject *resultobj = 0;
22725 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22726 int arg2 ;
22727 void *argp1 = 0 ;
22728 int res1 = 0 ;
22729 int val2 ;
22730 int ecode2 = 0 ;
22731 PyObject *swig_obj[2] ;
22732
22733 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22735 if (!SWIG_IsOK(res1)) {
22736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22737 }
22738 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22739 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22740 if (!SWIG_IsOK(ecode2)) {
22741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22742 }
22743 arg2 = static_cast< int >(val2);
22744 if (arg1) (arg1)->m_y = arg2;
22745
22746 resultobj = SWIG_Py_Void();
22747 return resultobj;
22748 fail:
22749 return NULL;
22750 }
22751
22752
22753 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22754 PyObject *resultobj = 0;
22755 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22756 int result;
22757 void *argp1 = 0 ;
22758 int res1 = 0 ;
22759 PyObject *swig_obj[1] ;
22760
22761 if (!args) SWIG_fail;
22762 swig_obj[0] = args;
22763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22764 if (!SWIG_IsOK(res1)) {
22765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22766 }
22767 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22768 result = (int) ((arg1)->m_y);
22769 resultobj = SWIG_From_int(static_cast< int >(result));
22770 return resultobj;
22771 fail:
22772 return NULL;
22773 }
22774
22775
22776 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22777 PyObject *resultobj = 0;
22778 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22779 long arg2 ;
22780 void *argp1 = 0 ;
22781 int res1 = 0 ;
22782 long val2 ;
22783 int ecode2 = 0 ;
22784 PyObject *swig_obj[2] ;
22785
22786 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22788 if (!SWIG_IsOK(res1)) {
22789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22790 }
22791 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22792 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22793 if (!SWIG_IsOK(ecode2)) {
22794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22795 }
22796 arg2 = static_cast< long >(val2);
22797 if (arg1) (arg1)->m_keyCode = arg2;
22798
22799 resultobj = SWIG_Py_Void();
22800 return resultobj;
22801 fail:
22802 return NULL;
22803 }
22804
22805
22806 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22807 PyObject *resultobj = 0;
22808 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22809 long result;
22810 void *argp1 = 0 ;
22811 int res1 = 0 ;
22812 PyObject *swig_obj[1] ;
22813
22814 if (!args) SWIG_fail;
22815 swig_obj[0] = args;
22816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22817 if (!SWIG_IsOK(res1)) {
22818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22819 }
22820 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22821 result = (long) ((arg1)->m_keyCode);
22822 resultobj = SWIG_From_long(static_cast< long >(result));
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22830 PyObject *resultobj = 0;
22831 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22832 bool arg2 ;
22833 void *argp1 = 0 ;
22834 int res1 = 0 ;
22835 bool val2 ;
22836 int ecode2 = 0 ;
22837 PyObject *swig_obj[2] ;
22838
22839 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22841 if (!SWIG_IsOK(res1)) {
22842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22843 }
22844 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22845 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22846 if (!SWIG_IsOK(ecode2)) {
22847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22848 }
22849 arg2 = static_cast< bool >(val2);
22850 if (arg1) (arg1)->m_controlDown = arg2;
22851
22852 resultobj = SWIG_Py_Void();
22853 return resultobj;
22854 fail:
22855 return NULL;
22856 }
22857
22858
22859 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22860 PyObject *resultobj = 0;
22861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22862 bool result;
22863 void *argp1 = 0 ;
22864 int res1 = 0 ;
22865 PyObject *swig_obj[1] ;
22866
22867 if (!args) SWIG_fail;
22868 swig_obj[0] = args;
22869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22870 if (!SWIG_IsOK(res1)) {
22871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22872 }
22873 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22874 result = (bool) ((arg1)->m_controlDown);
22875 {
22876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22877 }
22878 return resultobj;
22879 fail:
22880 return NULL;
22881 }
22882
22883
22884 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22885 PyObject *resultobj = 0;
22886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22887 bool arg2 ;
22888 void *argp1 = 0 ;
22889 int res1 = 0 ;
22890 bool val2 ;
22891 int ecode2 = 0 ;
22892 PyObject *swig_obj[2] ;
22893
22894 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22896 if (!SWIG_IsOK(res1)) {
22897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22898 }
22899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22900 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22901 if (!SWIG_IsOK(ecode2)) {
22902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22903 }
22904 arg2 = static_cast< bool >(val2);
22905 if (arg1) (arg1)->m_shiftDown = arg2;
22906
22907 resultobj = SWIG_Py_Void();
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22915 PyObject *resultobj = 0;
22916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22917 bool result;
22918 void *argp1 = 0 ;
22919 int res1 = 0 ;
22920 PyObject *swig_obj[1] ;
22921
22922 if (!args) SWIG_fail;
22923 swig_obj[0] = args;
22924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22925 if (!SWIG_IsOK(res1)) {
22926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22927 }
22928 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22929 result = (bool) ((arg1)->m_shiftDown);
22930 {
22931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22932 }
22933 return resultobj;
22934 fail:
22935 return NULL;
22936 }
22937
22938
22939 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22940 PyObject *resultobj = 0;
22941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22942 bool arg2 ;
22943 void *argp1 = 0 ;
22944 int res1 = 0 ;
22945 bool val2 ;
22946 int ecode2 = 0 ;
22947 PyObject *swig_obj[2] ;
22948
22949 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22951 if (!SWIG_IsOK(res1)) {
22952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22953 }
22954 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22955 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22956 if (!SWIG_IsOK(ecode2)) {
22957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22958 }
22959 arg2 = static_cast< bool >(val2);
22960 if (arg1) (arg1)->m_altDown = arg2;
22961
22962 resultobj = SWIG_Py_Void();
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22970 PyObject *resultobj = 0;
22971 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22972 bool result;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 PyObject *swig_obj[1] ;
22976
22977 if (!args) SWIG_fail;
22978 swig_obj[0] = args;
22979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22980 if (!SWIG_IsOK(res1)) {
22981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22982 }
22983 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22984 result = (bool) ((arg1)->m_altDown);
22985 {
22986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22987 }
22988 return resultobj;
22989 fail:
22990 return NULL;
22991 }
22992
22993
22994 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22995 PyObject *resultobj = 0;
22996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22997 bool arg2 ;
22998 void *argp1 = 0 ;
22999 int res1 = 0 ;
23000 bool val2 ;
23001 int ecode2 = 0 ;
23002 PyObject *swig_obj[2] ;
23003
23004 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23006 if (!SWIG_IsOK(res1)) {
23007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23008 }
23009 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23010 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23011 if (!SWIG_IsOK(ecode2)) {
23012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23013 }
23014 arg2 = static_cast< bool >(val2);
23015 if (arg1) (arg1)->m_metaDown = arg2;
23016
23017 resultobj = SWIG_Py_Void();
23018 return resultobj;
23019 fail:
23020 return NULL;
23021 }
23022
23023
23024 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23025 PyObject *resultobj = 0;
23026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23027 bool result;
23028 void *argp1 = 0 ;
23029 int res1 = 0 ;
23030 PyObject *swig_obj[1] ;
23031
23032 if (!args) SWIG_fail;
23033 swig_obj[0] = args;
23034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23035 if (!SWIG_IsOK(res1)) {
23036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23037 }
23038 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23039 result = (bool) ((arg1)->m_metaDown);
23040 {
23041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23042 }
23043 return resultobj;
23044 fail:
23045 return NULL;
23046 }
23047
23048
23049 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23050 PyObject *resultobj = 0;
23051 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23052 bool arg2 ;
23053 void *argp1 = 0 ;
23054 int res1 = 0 ;
23055 bool val2 ;
23056 int ecode2 = 0 ;
23057 PyObject *swig_obj[2] ;
23058
23059 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23061 if (!SWIG_IsOK(res1)) {
23062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23063 }
23064 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23065 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23066 if (!SWIG_IsOK(ecode2)) {
23067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23068 }
23069 arg2 = static_cast< bool >(val2);
23070 if (arg1) (arg1)->m_scanCode = arg2;
23071
23072 resultobj = SWIG_Py_Void();
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *resultobj = 0;
23081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23082 bool result;
23083 void *argp1 = 0 ;
23084 int res1 = 0 ;
23085 PyObject *swig_obj[1] ;
23086
23087 if (!args) SWIG_fail;
23088 swig_obj[0] = args;
23089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23092 }
23093 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23094 result = (bool) ((arg1)->m_scanCode);
23095 {
23096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23097 }
23098 return resultobj;
23099 fail:
23100 return NULL;
23101 }
23102
23103
23104 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23105 PyObject *resultobj = 0;
23106 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23107 unsigned int arg2 ;
23108 void *argp1 = 0 ;
23109 int res1 = 0 ;
23110 unsigned int val2 ;
23111 int ecode2 = 0 ;
23112 PyObject *swig_obj[2] ;
23113
23114 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23116 if (!SWIG_IsOK(res1)) {
23117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23118 }
23119 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23120 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23121 if (!SWIG_IsOK(ecode2)) {
23122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23123 }
23124 arg2 = static_cast< unsigned int >(val2);
23125 if (arg1) (arg1)->m_rawCode = arg2;
23126
23127 resultobj = SWIG_Py_Void();
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23135 PyObject *resultobj = 0;
23136 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23137 unsigned int result;
23138 void *argp1 = 0 ;
23139 int res1 = 0 ;
23140 PyObject *swig_obj[1] ;
23141
23142 if (!args) SWIG_fail;
23143 swig_obj[0] = args;
23144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23145 if (!SWIG_IsOK(res1)) {
23146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23147 }
23148 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23149 result = (unsigned int) ((arg1)->m_rawCode);
23150 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23151 return resultobj;
23152 fail:
23153 return NULL;
23154 }
23155
23156
23157 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23158 PyObject *resultobj = 0;
23159 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23160 unsigned int arg2 ;
23161 void *argp1 = 0 ;
23162 int res1 = 0 ;
23163 unsigned int val2 ;
23164 int ecode2 = 0 ;
23165 PyObject *swig_obj[2] ;
23166
23167 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23169 if (!SWIG_IsOK(res1)) {
23170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23171 }
23172 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23173 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23174 if (!SWIG_IsOK(ecode2)) {
23175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23176 }
23177 arg2 = static_cast< unsigned int >(val2);
23178 if (arg1) (arg1)->m_rawFlags = arg2;
23179
23180 resultobj = SWIG_Py_Void();
23181 return resultobj;
23182 fail:
23183 return NULL;
23184 }
23185
23186
23187 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23188 PyObject *resultobj = 0;
23189 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23190 unsigned int result;
23191 void *argp1 = 0 ;
23192 int res1 = 0 ;
23193 PyObject *swig_obj[1] ;
23194
23195 if (!args) SWIG_fail;
23196 swig_obj[0] = args;
23197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23198 if (!SWIG_IsOK(res1)) {
23199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23200 }
23201 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23202 result = (unsigned int) ((arg1)->m_rawFlags);
23203 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23211 PyObject *obj;
23212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23213 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23214 return SWIG_Py_Void();
23215 }
23216
23217 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23218 return SWIG_Python_InitShadowInstance(args);
23219 }
23220
23221 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23222 PyObject *resultobj = 0;
23223 wxSize const &arg1_defvalue = wxDefaultSize ;
23224 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23225 int arg2 = (int) 0 ;
23226 wxSizeEvent *result = 0 ;
23227 wxSize temp1 ;
23228 int val2 ;
23229 int ecode2 = 0 ;
23230 PyObject * obj0 = 0 ;
23231 PyObject * obj1 = 0 ;
23232 char * kwnames[] = {
23233 (char *) "sz",(char *) "winid", NULL
23234 };
23235
23236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23237 if (obj0) {
23238 {
23239 arg1 = &temp1;
23240 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23241 }
23242 }
23243 if (obj1) {
23244 ecode2 = SWIG_AsVal_int(obj1, &val2);
23245 if (!SWIG_IsOK(ecode2)) {
23246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23247 }
23248 arg2 = static_cast< int >(val2);
23249 }
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23257 return resultobj;
23258 fail:
23259 return NULL;
23260 }
23261
23262
23263 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23264 PyObject *resultobj = 0;
23265 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23266 wxSize result;
23267 void *argp1 = 0 ;
23268 int res1 = 0 ;
23269 PyObject *swig_obj[1] ;
23270
23271 if (!args) SWIG_fail;
23272 swig_obj[0] = args;
23273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23274 if (!SWIG_IsOK(res1)) {
23275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23276 }
23277 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 result = ((wxSizeEvent const *)arg1)->GetSize();
23281 wxPyEndAllowThreads(__tstate);
23282 if (PyErr_Occurred()) SWIG_fail;
23283 }
23284 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23285 return resultobj;
23286 fail:
23287 return NULL;
23288 }
23289
23290
23291 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23292 PyObject *resultobj = 0;
23293 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23294 wxRect result;
23295 void *argp1 = 0 ;
23296 int res1 = 0 ;
23297 PyObject *swig_obj[1] ;
23298
23299 if (!args) SWIG_fail;
23300 swig_obj[0] = args;
23301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23302 if (!SWIG_IsOK(res1)) {
23303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23304 }
23305 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 result = ((wxSizeEvent const *)arg1)->GetRect();
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23313 return resultobj;
23314 fail:
23315 return NULL;
23316 }
23317
23318
23319 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23320 PyObject *resultobj = 0;
23321 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23322 wxRect arg2 ;
23323 void *argp1 = 0 ;
23324 int res1 = 0 ;
23325 void *argp2 ;
23326 int res2 = 0 ;
23327 PyObject * obj0 = 0 ;
23328 PyObject * obj1 = 0 ;
23329 char * kwnames[] = {
23330 (char *) "self",(char *) "rect", NULL
23331 };
23332
23333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23335 if (!SWIG_IsOK(res1)) {
23336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23337 }
23338 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23339 {
23340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23341 if (!SWIG_IsOK(res2)) {
23342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23343 }
23344 if (!argp2) {
23345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23346 } else {
23347 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23348 arg2 = *temp;
23349 if (SWIG_IsNewObj(res2)) delete temp;
23350 }
23351 }
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 (arg1)->SetRect(arg2);
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 resultobj = SWIG_Py_Void();
23359 return resultobj;
23360 fail:
23361 return NULL;
23362 }
23363
23364
23365 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23366 PyObject *resultobj = 0;
23367 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23368 wxSize arg2 ;
23369 void *argp1 = 0 ;
23370 int res1 = 0 ;
23371 void *argp2 ;
23372 int res2 = 0 ;
23373 PyObject * obj0 = 0 ;
23374 PyObject * obj1 = 0 ;
23375 char * kwnames[] = {
23376 (char *) "self",(char *) "size", NULL
23377 };
23378
23379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23381 if (!SWIG_IsOK(res1)) {
23382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23383 }
23384 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23385 {
23386 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23387 if (!SWIG_IsOK(res2)) {
23388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23389 }
23390 if (!argp2) {
23391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23392 } else {
23393 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23394 arg2 = *temp;
23395 if (SWIG_IsNewObj(res2)) delete temp;
23396 }
23397 }
23398 {
23399 PyThreadState* __tstate = wxPyBeginAllowThreads();
23400 wxSizeEvent_SetSize(arg1,arg2);
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 resultobj = SWIG_Py_Void();
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23414 wxSize *arg2 = (wxSize *) 0 ;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 void *argp2 = 0 ;
23418 int res2 = 0 ;
23419 PyObject *swig_obj[2] ;
23420
23421 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23423 if (!SWIG_IsOK(res1)) {
23424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23425 }
23426 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23427 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23428 if (!SWIG_IsOK(res2)) {
23429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23430 }
23431 arg2 = reinterpret_cast< wxSize * >(argp2);
23432 if (arg1) (arg1)->m_size = *arg2;
23433
23434 resultobj = SWIG_Py_Void();
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *resultobj = 0;
23443 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23444 wxSize *result = 0 ;
23445 void *argp1 = 0 ;
23446 int res1 = 0 ;
23447 PyObject *swig_obj[1] ;
23448
23449 if (!args) SWIG_fail;
23450 swig_obj[0] = args;
23451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23452 if (!SWIG_IsOK(res1)) {
23453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23454 }
23455 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23456 result = (wxSize *)& ((arg1)->m_size);
23457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23458 return resultobj;
23459 fail:
23460 return NULL;
23461 }
23462
23463
23464 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23465 PyObject *resultobj = 0;
23466 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23467 wxRect *arg2 = (wxRect *) 0 ;
23468 void *argp1 = 0 ;
23469 int res1 = 0 ;
23470 void *argp2 = 0 ;
23471 int res2 = 0 ;
23472 PyObject *swig_obj[2] ;
23473
23474 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23476 if (!SWIG_IsOK(res1)) {
23477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23478 }
23479 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23480 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23481 if (!SWIG_IsOK(res2)) {
23482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23483 }
23484 arg2 = reinterpret_cast< wxRect * >(argp2);
23485 if (arg1) (arg1)->m_rect = *arg2;
23486
23487 resultobj = SWIG_Py_Void();
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23495 PyObject *resultobj = 0;
23496 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23497 wxRect *result = 0 ;
23498 void *argp1 = 0 ;
23499 int res1 = 0 ;
23500 PyObject *swig_obj[1] ;
23501
23502 if (!args) SWIG_fail;
23503 swig_obj[0] = args;
23504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23505 if (!SWIG_IsOK(res1)) {
23506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23507 }
23508 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23509 result = (wxRect *)& ((arg1)->m_rect);
23510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23511 return resultobj;
23512 fail:
23513 return NULL;
23514 }
23515
23516
23517 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23518 PyObject *obj;
23519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23520 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23521 return SWIG_Py_Void();
23522 }
23523
23524 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23525 return SWIG_Python_InitShadowInstance(args);
23526 }
23527
23528 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23529 PyObject *resultobj = 0;
23530 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23531 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23532 int arg2 = (int) 0 ;
23533 wxMoveEvent *result = 0 ;
23534 wxPoint temp1 ;
23535 int val2 ;
23536 int ecode2 = 0 ;
23537 PyObject * obj0 = 0 ;
23538 PyObject * obj1 = 0 ;
23539 char * kwnames[] = {
23540 (char *) "pos",(char *) "winid", NULL
23541 };
23542
23543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23544 if (obj0) {
23545 {
23546 arg1 = &temp1;
23547 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23548 }
23549 }
23550 if (obj1) {
23551 ecode2 = SWIG_AsVal_int(obj1, &val2);
23552 if (!SWIG_IsOK(ecode2)) {
23553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23554 }
23555 arg2 = static_cast< int >(val2);
23556 }
23557 {
23558 PyThreadState* __tstate = wxPyBeginAllowThreads();
23559 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23564 return resultobj;
23565 fail:
23566 return NULL;
23567 }
23568
23569
23570 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23571 PyObject *resultobj = 0;
23572 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23573 wxPoint result;
23574 void *argp1 = 0 ;
23575 int res1 = 0 ;
23576 PyObject *swig_obj[1] ;
23577
23578 if (!args) SWIG_fail;
23579 swig_obj[0] = args;
23580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23581 if (!SWIG_IsOK(res1)) {
23582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23583 }
23584 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23585 {
23586 PyThreadState* __tstate = wxPyBeginAllowThreads();
23587 result = ((wxMoveEvent const *)arg1)->GetPosition();
23588 wxPyEndAllowThreads(__tstate);
23589 if (PyErr_Occurred()) SWIG_fail;
23590 }
23591 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23592 return resultobj;
23593 fail:
23594 return NULL;
23595 }
23596
23597
23598 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23599 PyObject *resultobj = 0;
23600 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23601 wxRect result;
23602 void *argp1 = 0 ;
23603 int res1 = 0 ;
23604 PyObject *swig_obj[1] ;
23605
23606 if (!args) SWIG_fail;
23607 swig_obj[0] = args;
23608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23609 if (!SWIG_IsOK(res1)) {
23610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23611 }
23612 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23613 {
23614 PyThreadState* __tstate = wxPyBeginAllowThreads();
23615 result = ((wxMoveEvent const *)arg1)->GetRect();
23616 wxPyEndAllowThreads(__tstate);
23617 if (PyErr_Occurred()) SWIG_fail;
23618 }
23619 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23620 return resultobj;
23621 fail:
23622 return NULL;
23623 }
23624
23625
23626 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23627 PyObject *resultobj = 0;
23628 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23629 wxRect *arg2 = 0 ;
23630 void *argp1 = 0 ;
23631 int res1 = 0 ;
23632 wxRect temp2 ;
23633 PyObject * obj0 = 0 ;
23634 PyObject * obj1 = 0 ;
23635 char * kwnames[] = {
23636 (char *) "self",(char *) "rect", NULL
23637 };
23638
23639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23641 if (!SWIG_IsOK(res1)) {
23642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23643 }
23644 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23645 {
23646 arg2 = &temp2;
23647 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23648 }
23649 {
23650 PyThreadState* __tstate = wxPyBeginAllowThreads();
23651 (arg1)->SetRect((wxRect const &)*arg2);
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 resultobj = SWIG_Py_Void();
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23663 PyObject *resultobj = 0;
23664 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23665 wxPoint *arg2 = 0 ;
23666 void *argp1 = 0 ;
23667 int res1 = 0 ;
23668 wxPoint temp2 ;
23669 PyObject * obj0 = 0 ;
23670 PyObject * obj1 = 0 ;
23671 char * kwnames[] = {
23672 (char *) "self",(char *) "pos", NULL
23673 };
23674
23675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23677 if (!SWIG_IsOK(res1)) {
23678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23679 }
23680 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23681 {
23682 arg2 = &temp2;
23683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23684 }
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 (arg1)->SetPosition((wxPoint const &)*arg2);
23688 wxPyEndAllowThreads(__tstate);
23689 if (PyErr_Occurred()) SWIG_fail;
23690 }
23691 resultobj = SWIG_Py_Void();
23692 return resultobj;
23693 fail:
23694 return NULL;
23695 }
23696
23697
23698 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23699 PyObject *obj;
23700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23701 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23702 return SWIG_Py_Void();
23703 }
23704
23705 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23706 return SWIG_Python_InitShadowInstance(args);
23707 }
23708
23709 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23710 PyObject *resultobj = 0;
23711 int arg1 = (int) 0 ;
23712 wxPaintEvent *result = 0 ;
23713 int val1 ;
23714 int ecode1 = 0 ;
23715 PyObject * obj0 = 0 ;
23716 char * kwnames[] = {
23717 (char *) "Id", NULL
23718 };
23719
23720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23721 if (obj0) {
23722 ecode1 = SWIG_AsVal_int(obj0, &val1);
23723 if (!SWIG_IsOK(ecode1)) {
23724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23725 }
23726 arg1 = static_cast< int >(val1);
23727 }
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 PyObject *obj;
23743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23744 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23745 return SWIG_Py_Void();
23746 }
23747
23748 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23749 return SWIG_Python_InitShadowInstance(args);
23750 }
23751
23752 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj = 0;
23754 int arg1 = (int) 0 ;
23755 wxNcPaintEvent *result = 0 ;
23756 int val1 ;
23757 int ecode1 = 0 ;
23758 PyObject * obj0 = 0 ;
23759 char * kwnames[] = {
23760 (char *) "winid", NULL
23761 };
23762
23763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23764 if (obj0) {
23765 ecode1 = SWIG_AsVal_int(obj0, &val1);
23766 if (!SWIG_IsOK(ecode1)) {
23767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23768 }
23769 arg1 = static_cast< int >(val1);
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23785 PyObject *obj;
23786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23787 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23788 return SWIG_Py_Void();
23789 }
23790
23791 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23792 return SWIG_Python_InitShadowInstance(args);
23793 }
23794
23795 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj = 0;
23797 int arg1 = (int) 0 ;
23798 wxDC *arg2 = (wxDC *) NULL ;
23799 wxEraseEvent *result = 0 ;
23800 int val1 ;
23801 int ecode1 = 0 ;
23802 void *argp2 = 0 ;
23803 int res2 = 0 ;
23804 PyObject * obj0 = 0 ;
23805 PyObject * obj1 = 0 ;
23806 char * kwnames[] = {
23807 (char *) "Id",(char *) "dc", NULL
23808 };
23809
23810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23811 if (obj0) {
23812 ecode1 = SWIG_AsVal_int(obj0, &val1);
23813 if (!SWIG_IsOK(ecode1)) {
23814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23815 }
23816 arg1 = static_cast< int >(val1);
23817 }
23818 if (obj1) {
23819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23820 if (!SWIG_IsOK(res2)) {
23821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23822 }
23823 arg2 = reinterpret_cast< wxDC * >(argp2);
23824 }
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23828 wxPyEndAllowThreads(__tstate);
23829 if (PyErr_Occurred()) SWIG_fail;
23830 }
23831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23832 return resultobj;
23833 fail:
23834 return NULL;
23835 }
23836
23837
23838 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23839 PyObject *resultobj = 0;
23840 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23841 wxDC *result = 0 ;
23842 void *argp1 = 0 ;
23843 int res1 = 0 ;
23844 PyObject *swig_obj[1] ;
23845
23846 if (!args) SWIG_fail;
23847 swig_obj[0] = args;
23848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23849 if (!SWIG_IsOK(res1)) {
23850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23851 }
23852 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23853 {
23854 PyThreadState* __tstate = wxPyBeginAllowThreads();
23855 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23856 wxPyEndAllowThreads(__tstate);
23857 if (PyErr_Occurred()) SWIG_fail;
23858 }
23859 {
23860 resultobj = wxPyMake_wxObject(result, (bool)0);
23861 }
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *obj;
23870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23871 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23872 return SWIG_Py_Void();
23873 }
23874
23875 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23876 return SWIG_Python_InitShadowInstance(args);
23877 }
23878
23879 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj = 0;
23881 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23882 int arg2 = (int) 0 ;
23883 wxFocusEvent *result = 0 ;
23884 int val1 ;
23885 int ecode1 = 0 ;
23886 int val2 ;
23887 int ecode2 = 0 ;
23888 PyObject * obj0 = 0 ;
23889 PyObject * obj1 = 0 ;
23890 char * kwnames[] = {
23891 (char *) "type",(char *) "winid", NULL
23892 };
23893
23894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23895 if (obj0) {
23896 ecode1 = SWIG_AsVal_int(obj0, &val1);
23897 if (!SWIG_IsOK(ecode1)) {
23898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23899 }
23900 arg1 = static_cast< wxEventType >(val1);
23901 }
23902 if (obj1) {
23903 ecode2 = SWIG_AsVal_int(obj1, &val2);
23904 if (!SWIG_IsOK(ecode2)) {
23905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23906 }
23907 arg2 = static_cast< int >(val2);
23908 }
23909 {
23910 PyThreadState* __tstate = wxPyBeginAllowThreads();
23911 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23912 wxPyEndAllowThreads(__tstate);
23913 if (PyErr_Occurred()) SWIG_fail;
23914 }
23915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23923 PyObject *resultobj = 0;
23924 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23925 wxWindow *result = 0 ;
23926 void *argp1 = 0 ;
23927 int res1 = 0 ;
23928 PyObject *swig_obj[1] ;
23929
23930 if (!args) SWIG_fail;
23931 swig_obj[0] = args;
23932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23933 if (!SWIG_IsOK(res1)) {
23934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23935 }
23936 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 {
23944 resultobj = wxPyMake_wxObject(result, (bool)0);
23945 }
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23953 PyObject *resultobj = 0;
23954 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23955 wxWindow *arg2 = (wxWindow *) 0 ;
23956 void *argp1 = 0 ;
23957 int res1 = 0 ;
23958 void *argp2 = 0 ;
23959 int res2 = 0 ;
23960 PyObject * obj0 = 0 ;
23961 PyObject * obj1 = 0 ;
23962 char * kwnames[] = {
23963 (char *) "self",(char *) "win", NULL
23964 };
23965
23966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23968 if (!SWIG_IsOK(res1)) {
23969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23970 }
23971 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23973 if (!SWIG_IsOK(res2)) {
23974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23975 }
23976 arg2 = reinterpret_cast< wxWindow * >(argp2);
23977 {
23978 PyThreadState* __tstate = wxPyBeginAllowThreads();
23979 (arg1)->SetWindow(arg2);
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 resultobj = SWIG_Py_Void();
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23991 PyObject *obj;
23992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23993 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23994 return SWIG_Py_Void();
23995 }
23996
23997 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23998 return SWIG_Python_InitShadowInstance(args);
23999 }
24000
24001 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24002 PyObject *resultobj = 0;
24003 wxWindow *arg1 = (wxWindow *) NULL ;
24004 wxChildFocusEvent *result = 0 ;
24005 void *argp1 = 0 ;
24006 int res1 = 0 ;
24007 PyObject * obj0 = 0 ;
24008 char * kwnames[] = {
24009 (char *) "win", NULL
24010 };
24011
24012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24013 if (obj0) {
24014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24015 if (!SWIG_IsOK(res1)) {
24016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24017 }
24018 arg1 = reinterpret_cast< wxWindow * >(argp1);
24019 }
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24034 PyObject *resultobj = 0;
24035 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24036 wxWindow *result = 0 ;
24037 void *argp1 = 0 ;
24038 int res1 = 0 ;
24039 PyObject *swig_obj[1] ;
24040
24041 if (!args) SWIG_fail;
24042 swig_obj[0] = args;
24043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24044 if (!SWIG_IsOK(res1)) {
24045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24046 }
24047 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24048 {
24049 PyThreadState* __tstate = wxPyBeginAllowThreads();
24050 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24051 wxPyEndAllowThreads(__tstate);
24052 if (PyErr_Occurred()) SWIG_fail;
24053 }
24054 {
24055 resultobj = wxPyMake_wxObject(result, (bool)0);
24056 }
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24064 PyObject *obj;
24065 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24066 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24067 return SWIG_Py_Void();
24068 }
24069
24070 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24071 return SWIG_Python_InitShadowInstance(args);
24072 }
24073
24074 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24075 PyObject *resultobj = 0;
24076 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24077 bool arg2 = (bool) true ;
24078 int arg3 = (int) 0 ;
24079 wxActivateEvent *result = 0 ;
24080 int val1 ;
24081 int ecode1 = 0 ;
24082 bool val2 ;
24083 int ecode2 = 0 ;
24084 int val3 ;
24085 int ecode3 = 0 ;
24086 PyObject * obj0 = 0 ;
24087 PyObject * obj1 = 0 ;
24088 PyObject * obj2 = 0 ;
24089 char * kwnames[] = {
24090 (char *) "type",(char *) "active",(char *) "Id", NULL
24091 };
24092
24093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24094 if (obj0) {
24095 ecode1 = SWIG_AsVal_int(obj0, &val1);
24096 if (!SWIG_IsOK(ecode1)) {
24097 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24098 }
24099 arg1 = static_cast< wxEventType >(val1);
24100 }
24101 if (obj1) {
24102 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24103 if (!SWIG_IsOK(ecode2)) {
24104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24105 }
24106 arg2 = static_cast< bool >(val2);
24107 }
24108 if (obj2) {
24109 ecode3 = SWIG_AsVal_int(obj2, &val3);
24110 if (!SWIG_IsOK(ecode3)) {
24111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24112 }
24113 arg3 = static_cast< int >(val3);
24114 }
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24118 wxPyEndAllowThreads(__tstate);
24119 if (PyErr_Occurred()) SWIG_fail;
24120 }
24121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24122 return resultobj;
24123 fail:
24124 return NULL;
24125 }
24126
24127
24128 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24129 PyObject *resultobj = 0;
24130 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24131 bool result;
24132 void *argp1 = 0 ;
24133 int res1 = 0 ;
24134 PyObject *swig_obj[1] ;
24135
24136 if (!args) SWIG_fail;
24137 swig_obj[0] = args;
24138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24139 if (!SWIG_IsOK(res1)) {
24140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24141 }
24142 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 {
24150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24151 }
24152 return resultobj;
24153 fail:
24154 return NULL;
24155 }
24156
24157
24158 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24159 PyObject *obj;
24160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24161 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24162 return SWIG_Py_Void();
24163 }
24164
24165 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24166 return SWIG_Python_InitShadowInstance(args);
24167 }
24168
24169 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24170 PyObject *resultobj = 0;
24171 int arg1 = (int) 0 ;
24172 wxInitDialogEvent *result = 0 ;
24173 int val1 ;
24174 int ecode1 = 0 ;
24175 PyObject * obj0 = 0 ;
24176 char * kwnames[] = {
24177 (char *) "Id", NULL
24178 };
24179
24180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24181 if (obj0) {
24182 ecode1 = SWIG_AsVal_int(obj0, &val1);
24183 if (!SWIG_IsOK(ecode1)) {
24184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24185 }
24186 arg1 = static_cast< int >(val1);
24187 }
24188 {
24189 PyThreadState* __tstate = wxPyBeginAllowThreads();
24190 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24191 wxPyEndAllowThreads(__tstate);
24192 if (PyErr_Occurred()) SWIG_fail;
24193 }
24194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24195 return resultobj;
24196 fail:
24197 return NULL;
24198 }
24199
24200
24201 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24202 PyObject *obj;
24203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24204 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24205 return SWIG_Py_Void();
24206 }
24207
24208 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24209 return SWIG_Python_InitShadowInstance(args);
24210 }
24211
24212 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24213 PyObject *resultobj = 0;
24214 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24215 int arg2 = (int) 0 ;
24216 wxMenu *arg3 = (wxMenu *) NULL ;
24217 wxMenuEvent *result = 0 ;
24218 int val1 ;
24219 int ecode1 = 0 ;
24220 int val2 ;
24221 int ecode2 = 0 ;
24222 void *argp3 = 0 ;
24223 int res3 = 0 ;
24224 PyObject * obj0 = 0 ;
24225 PyObject * obj1 = 0 ;
24226 PyObject * obj2 = 0 ;
24227 char * kwnames[] = {
24228 (char *) "type",(char *) "winid",(char *) "menu", NULL
24229 };
24230
24231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24232 if (obj0) {
24233 ecode1 = SWIG_AsVal_int(obj0, &val1);
24234 if (!SWIG_IsOK(ecode1)) {
24235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24236 }
24237 arg1 = static_cast< wxEventType >(val1);
24238 }
24239 if (obj1) {
24240 ecode2 = SWIG_AsVal_int(obj1, &val2);
24241 if (!SWIG_IsOK(ecode2)) {
24242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24243 }
24244 arg2 = static_cast< int >(val2);
24245 }
24246 if (obj2) {
24247 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24248 if (!SWIG_IsOK(res3)) {
24249 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24250 }
24251 arg3 = reinterpret_cast< wxMenu * >(argp3);
24252 }
24253 {
24254 PyThreadState* __tstate = wxPyBeginAllowThreads();
24255 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24256 wxPyEndAllowThreads(__tstate);
24257 if (PyErr_Occurred()) SWIG_fail;
24258 }
24259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24267 PyObject *resultobj = 0;
24268 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24269 int result;
24270 void *argp1 = 0 ;
24271 int res1 = 0 ;
24272 PyObject *swig_obj[1] ;
24273
24274 if (!args) SWIG_fail;
24275 swig_obj[0] = args;
24276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24277 if (!SWIG_IsOK(res1)) {
24278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24279 }
24280 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24284 wxPyEndAllowThreads(__tstate);
24285 if (PyErr_Occurred()) SWIG_fail;
24286 }
24287 resultobj = SWIG_From_int(static_cast< int >(result));
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *resultobj = 0;
24296 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24297 bool result;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 PyObject *swig_obj[1] ;
24301
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24307 }
24308 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 PyObject *resultobj = 0;
24326 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24327 wxMenu *result = 0 ;
24328 void *argp1 = 0 ;
24329 int res1 = 0 ;
24330 PyObject *swig_obj[1] ;
24331
24332 if (!args) SWIG_fail;
24333 swig_obj[0] = args;
24334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24335 if (!SWIG_IsOK(res1)) {
24336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24337 }
24338 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24339 {
24340 PyThreadState* __tstate = wxPyBeginAllowThreads();
24341 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 {
24346 resultobj = wxPyMake_wxObject(result, (bool)0);
24347 }
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24355 PyObject *obj;
24356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24357 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24358 return SWIG_Py_Void();
24359 }
24360
24361 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24362 return SWIG_Python_InitShadowInstance(args);
24363 }
24364
24365 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24366 PyObject *resultobj = 0;
24367 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24368 int arg2 = (int) 0 ;
24369 wxCloseEvent *result = 0 ;
24370 int val1 ;
24371 int ecode1 = 0 ;
24372 int val2 ;
24373 int ecode2 = 0 ;
24374 PyObject * obj0 = 0 ;
24375 PyObject * obj1 = 0 ;
24376 char * kwnames[] = {
24377 (char *) "type",(char *) "winid", NULL
24378 };
24379
24380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24381 if (obj0) {
24382 ecode1 = SWIG_AsVal_int(obj0, &val1);
24383 if (!SWIG_IsOK(ecode1)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24385 }
24386 arg1 = static_cast< wxEventType >(val1);
24387 }
24388 if (obj1) {
24389 ecode2 = SWIG_AsVal_int(obj1, &val2);
24390 if (!SWIG_IsOK(ecode2)) {
24391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24392 }
24393 arg2 = static_cast< int >(val2);
24394 }
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj = 0;
24410 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24411 bool arg2 ;
24412 void *argp1 = 0 ;
24413 int res1 = 0 ;
24414 bool val2 ;
24415 int ecode2 = 0 ;
24416 PyObject * obj0 = 0 ;
24417 PyObject * obj1 = 0 ;
24418 char * kwnames[] = {
24419 (char *) "self",(char *) "logOff", NULL
24420 };
24421
24422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24424 if (!SWIG_IsOK(res1)) {
24425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24426 }
24427 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24429 if (!SWIG_IsOK(ecode2)) {
24430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24431 }
24432 arg2 = static_cast< bool >(val2);
24433 {
24434 PyThreadState* __tstate = wxPyBeginAllowThreads();
24435 (arg1)->SetLoggingOff(arg2);
24436 wxPyEndAllowThreads(__tstate);
24437 if (PyErr_Occurred()) SWIG_fail;
24438 }
24439 resultobj = SWIG_Py_Void();
24440 return resultobj;
24441 fail:
24442 return NULL;
24443 }
24444
24445
24446 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447 PyObject *resultobj = 0;
24448 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24449 bool result;
24450 void *argp1 = 0 ;
24451 int res1 = 0 ;
24452 PyObject *swig_obj[1] ;
24453
24454 if (!args) SWIG_fail;
24455 swig_obj[0] = args;
24456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24457 if (!SWIG_IsOK(res1)) {
24458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24459 }
24460 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24461 {
24462 PyThreadState* __tstate = wxPyBeginAllowThreads();
24463 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24464 wxPyEndAllowThreads(__tstate);
24465 if (PyErr_Occurred()) SWIG_fail;
24466 }
24467 {
24468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24469 }
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj = 0;
24478 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24479 bool arg2 = (bool) true ;
24480 void *argp1 = 0 ;
24481 int res1 = 0 ;
24482 bool val2 ;
24483 int ecode2 = 0 ;
24484 PyObject * obj0 = 0 ;
24485 PyObject * obj1 = 0 ;
24486 char * kwnames[] = {
24487 (char *) "self",(char *) "veto", NULL
24488 };
24489
24490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24492 if (!SWIG_IsOK(res1)) {
24493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24494 }
24495 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24496 if (obj1) {
24497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24498 if (!SWIG_IsOK(ecode2)) {
24499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24500 }
24501 arg2 = static_cast< bool >(val2);
24502 }
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 (arg1)->Veto(arg2);
24506 wxPyEndAllowThreads(__tstate);
24507 if (PyErr_Occurred()) SWIG_fail;
24508 }
24509 resultobj = SWIG_Py_Void();
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24517 PyObject *resultobj = 0;
24518 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24519 bool result;
24520 void *argp1 = 0 ;
24521 int res1 = 0 ;
24522 PyObject *swig_obj[1] ;
24523
24524 if (!args) SWIG_fail;
24525 swig_obj[0] = args;
24526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24527 if (!SWIG_IsOK(res1)) {
24528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24529 }
24530 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 {
24538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24539 }
24540 return resultobj;
24541 fail:
24542 return NULL;
24543 }
24544
24545
24546 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24547 PyObject *resultobj = 0;
24548 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24549 bool arg2 ;
24550 void *argp1 = 0 ;
24551 int res1 = 0 ;
24552 bool val2 ;
24553 int ecode2 = 0 ;
24554 PyObject * obj0 = 0 ;
24555 PyObject * obj1 = 0 ;
24556 char * kwnames[] = {
24557 (char *) "self",(char *) "canVeto", NULL
24558 };
24559
24560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24562 if (!SWIG_IsOK(res1)) {
24563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24564 }
24565 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24567 if (!SWIG_IsOK(ecode2)) {
24568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24569 }
24570 arg2 = static_cast< bool >(val2);
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 (arg1)->SetCanVeto(arg2);
24574 wxPyEndAllowThreads(__tstate);
24575 if (PyErr_Occurred()) SWIG_fail;
24576 }
24577 resultobj = SWIG_Py_Void();
24578 return resultobj;
24579 fail:
24580 return NULL;
24581 }
24582
24583
24584 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24585 PyObject *resultobj = 0;
24586 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24587 bool result;
24588 void *argp1 = 0 ;
24589 int res1 = 0 ;
24590 PyObject *swig_obj[1] ;
24591
24592 if (!args) SWIG_fail;
24593 swig_obj[0] = args;
24594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24595 if (!SWIG_IsOK(res1)) {
24596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24597 }
24598 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24602 wxPyEndAllowThreads(__tstate);
24603 if (PyErr_Occurred()) SWIG_fail;
24604 }
24605 {
24606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24607 }
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24615 PyObject *obj;
24616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24617 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24618 return SWIG_Py_Void();
24619 }
24620
24621 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24622 return SWIG_Python_InitShadowInstance(args);
24623 }
24624
24625 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24626 PyObject *resultobj = 0;
24627 int arg1 = (int) 0 ;
24628 bool arg2 = (bool) false ;
24629 wxShowEvent *result = 0 ;
24630 int val1 ;
24631 int ecode1 = 0 ;
24632 bool val2 ;
24633 int ecode2 = 0 ;
24634 PyObject * obj0 = 0 ;
24635 PyObject * obj1 = 0 ;
24636 char * kwnames[] = {
24637 (char *) "winid",(char *) "show", NULL
24638 };
24639
24640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24641 if (obj0) {
24642 ecode1 = SWIG_AsVal_int(obj0, &val1);
24643 if (!SWIG_IsOK(ecode1)) {
24644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24645 }
24646 arg1 = static_cast< int >(val1);
24647 }
24648 if (obj1) {
24649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24650 if (!SWIG_IsOK(ecode2)) {
24651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24652 }
24653 arg2 = static_cast< bool >(val2);
24654 }
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj = 0;
24670 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24671 bool arg2 ;
24672 void *argp1 = 0 ;
24673 int res1 = 0 ;
24674 bool val2 ;
24675 int ecode2 = 0 ;
24676 PyObject * obj0 = 0 ;
24677 PyObject * obj1 = 0 ;
24678 char * kwnames[] = {
24679 (char *) "self",(char *) "show", NULL
24680 };
24681
24682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24684 if (!SWIG_IsOK(res1)) {
24685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24686 }
24687 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24689 if (!SWIG_IsOK(ecode2)) {
24690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24691 }
24692 arg2 = static_cast< bool >(val2);
24693 {
24694 PyThreadState* __tstate = wxPyBeginAllowThreads();
24695 (arg1)->SetShow(arg2);
24696 wxPyEndAllowThreads(__tstate);
24697 if (PyErr_Occurred()) SWIG_fail;
24698 }
24699 resultobj = SWIG_Py_Void();
24700 return resultobj;
24701 fail:
24702 return NULL;
24703 }
24704
24705
24706 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24707 PyObject *resultobj = 0;
24708 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24709 bool result;
24710 void *argp1 = 0 ;
24711 int res1 = 0 ;
24712 PyObject *swig_obj[1] ;
24713
24714 if (!args) SWIG_fail;
24715 swig_obj[0] = args;
24716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24717 if (!SWIG_IsOK(res1)) {
24718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24719 }
24720 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24721 {
24722 PyThreadState* __tstate = wxPyBeginAllowThreads();
24723 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24724 wxPyEndAllowThreads(__tstate);
24725 if (PyErr_Occurred()) SWIG_fail;
24726 }
24727 {
24728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24729 }
24730 return resultobj;
24731 fail:
24732 return NULL;
24733 }
24734
24735
24736 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24737 PyObject *obj;
24738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24739 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24740 return SWIG_Py_Void();
24741 }
24742
24743 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24744 return SWIG_Python_InitShadowInstance(args);
24745 }
24746
24747 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj = 0;
24749 int arg1 = (int) 0 ;
24750 bool arg2 = (bool) true ;
24751 wxIconizeEvent *result = 0 ;
24752 int val1 ;
24753 int ecode1 = 0 ;
24754 bool val2 ;
24755 int ecode2 = 0 ;
24756 PyObject * obj0 = 0 ;
24757 PyObject * obj1 = 0 ;
24758 char * kwnames[] = {
24759 (char *) "id",(char *) "iconized", NULL
24760 };
24761
24762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24763 if (obj0) {
24764 ecode1 = SWIG_AsVal_int(obj0, &val1);
24765 if (!SWIG_IsOK(ecode1)) {
24766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24767 }
24768 arg1 = static_cast< int >(val1);
24769 }
24770 if (obj1) {
24771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24772 if (!SWIG_IsOK(ecode2)) {
24773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24774 }
24775 arg2 = static_cast< bool >(val2);
24776 }
24777 {
24778 PyThreadState* __tstate = wxPyBeginAllowThreads();
24779 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24780 wxPyEndAllowThreads(__tstate);
24781 if (PyErr_Occurred()) SWIG_fail;
24782 }
24783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24791 PyObject *resultobj = 0;
24792 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24793 bool result;
24794 void *argp1 = 0 ;
24795 int res1 = 0 ;
24796 PyObject *swig_obj[1] ;
24797
24798 if (!args) SWIG_fail;
24799 swig_obj[0] = args;
24800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24801 if (!SWIG_IsOK(res1)) {
24802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24803 }
24804 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 result = (bool)(arg1)->Iconized();
24808 wxPyEndAllowThreads(__tstate);
24809 if (PyErr_Occurred()) SWIG_fail;
24810 }
24811 {
24812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24813 }
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24821 PyObject *obj;
24822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24823 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24824 return SWIG_Py_Void();
24825 }
24826
24827 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24828 return SWIG_Python_InitShadowInstance(args);
24829 }
24830
24831 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj = 0;
24833 int arg1 = (int) 0 ;
24834 wxMaximizeEvent *result = 0 ;
24835 int val1 ;
24836 int ecode1 = 0 ;
24837 PyObject * obj0 = 0 ;
24838 char * kwnames[] = {
24839 (char *) "id", NULL
24840 };
24841
24842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24843 if (obj0) {
24844 ecode1 = SWIG_AsVal_int(obj0, &val1);
24845 if (!SWIG_IsOK(ecode1)) {
24846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24847 }
24848 arg1 = static_cast< int >(val1);
24849 }
24850 {
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24853 wxPyEndAllowThreads(__tstate);
24854 if (PyErr_Occurred()) SWIG_fail;
24855 }
24856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24864 PyObject *obj;
24865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24866 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24867 return SWIG_Py_Void();
24868 }
24869
24870 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24871 return SWIG_Python_InitShadowInstance(args);
24872 }
24873
24874 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24875 PyObject *resultobj = 0;
24876 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24877 wxPoint result;
24878 void *argp1 = 0 ;
24879 int res1 = 0 ;
24880 PyObject *swig_obj[1] ;
24881
24882 if (!args) SWIG_fail;
24883 swig_obj[0] = args;
24884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24885 if (!SWIG_IsOK(res1)) {
24886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24887 }
24888 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = (arg1)->GetPosition();
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24903 PyObject *resultobj = 0;
24904 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24905 int result;
24906 void *argp1 = 0 ;
24907 int res1 = 0 ;
24908 PyObject *swig_obj[1] ;
24909
24910 if (!args) SWIG_fail;
24911 swig_obj[0] = args;
24912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24913 if (!SWIG_IsOK(res1)) {
24914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24915 }
24916 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 result = (int)(arg1)->GetNumberOfFiles();
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 resultobj = SWIG_From_int(static_cast< int >(result));
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24931 PyObject *resultobj = 0;
24932 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24933 PyObject *result = 0 ;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 PyObject *swig_obj[1] ;
24937
24938 if (!args) SWIG_fail;
24939 swig_obj[0] = args;
24940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24941 if (!SWIG_IsOK(res1)) {
24942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24943 }
24944 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24945 {
24946 PyThreadState* __tstate = wxPyBeginAllowThreads();
24947 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24948 wxPyEndAllowThreads(__tstate);
24949 if (PyErr_Occurred()) SWIG_fail;
24950 }
24951 resultobj = result;
24952 return resultobj;
24953 fail:
24954 return NULL;
24955 }
24956
24957
24958 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24959 PyObject *obj;
24960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24961 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24962 return SWIG_Py_Void();
24963 }
24964
24965 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24966 PyObject *resultobj = 0;
24967 int arg1 = (int) 0 ;
24968 wxUpdateUIEvent *result = 0 ;
24969 int val1 ;
24970 int ecode1 = 0 ;
24971 PyObject * obj0 = 0 ;
24972 char * kwnames[] = {
24973 (char *) "commandId", NULL
24974 };
24975
24976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24977 if (obj0) {
24978 ecode1 = SWIG_AsVal_int(obj0, &val1);
24979 if (!SWIG_IsOK(ecode1)) {
24980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24981 }
24982 arg1 = static_cast< int >(val1);
24983 }
24984 {
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24998 PyObject *resultobj = 0;
24999 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25000 bool result;
25001 void *argp1 = 0 ;
25002 int res1 = 0 ;
25003 PyObject *swig_obj[1] ;
25004
25005 if (!args) SWIG_fail;
25006 swig_obj[0] = args;
25007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25008 if (!SWIG_IsOK(res1)) {
25009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25010 }
25011 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25012 {
25013 PyThreadState* __tstate = wxPyBeginAllowThreads();
25014 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25015 wxPyEndAllowThreads(__tstate);
25016 if (PyErr_Occurred()) SWIG_fail;
25017 }
25018 {
25019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25020 }
25021 return resultobj;
25022 fail:
25023 return NULL;
25024 }
25025
25026
25027 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25028 PyObject *resultobj = 0;
25029 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25030 bool result;
25031 void *argp1 = 0 ;
25032 int res1 = 0 ;
25033 PyObject *swig_obj[1] ;
25034
25035 if (!args) SWIG_fail;
25036 swig_obj[0] = args;
25037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25040 }
25041 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25042 {
25043 PyThreadState* __tstate = wxPyBeginAllowThreads();
25044 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 {
25049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25050 }
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25058 PyObject *resultobj = 0;
25059 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25060 bool result;
25061 void *argp1 = 0 ;
25062 int res1 = 0 ;
25063 PyObject *swig_obj[1] ;
25064
25065 if (!args) SWIG_fail;
25066 swig_obj[0] = args;
25067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25068 if (!SWIG_IsOK(res1)) {
25069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25070 }
25071 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25072 {
25073 PyThreadState* __tstate = wxPyBeginAllowThreads();
25074 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 {
25079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25080 }
25081 return resultobj;
25082 fail:
25083 return NULL;
25084 }
25085
25086
25087 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25088 PyObject *resultobj = 0;
25089 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25090 wxString result;
25091 void *argp1 = 0 ;
25092 int res1 = 0 ;
25093 PyObject *swig_obj[1] ;
25094
25095 if (!args) SWIG_fail;
25096 swig_obj[0] = args;
25097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25098 if (!SWIG_IsOK(res1)) {
25099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25100 }
25101 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 {
25109 #if wxUSE_UNICODE
25110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25111 #else
25112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25113 #endif
25114 }
25115 return resultobj;
25116 fail:
25117 return NULL;
25118 }
25119
25120
25121 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25122 PyObject *resultobj = 0;
25123 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25124 bool result;
25125 void *argp1 = 0 ;
25126 int res1 = 0 ;
25127 PyObject *swig_obj[1] ;
25128
25129 if (!args) SWIG_fail;
25130 swig_obj[0] = args;
25131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25132 if (!SWIG_IsOK(res1)) {
25133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25134 }
25135 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25139 wxPyEndAllowThreads(__tstate);
25140 if (PyErr_Occurred()) SWIG_fail;
25141 }
25142 {
25143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25144 }
25145 return resultobj;
25146 fail:
25147 return NULL;
25148 }
25149
25150
25151 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25152 PyObject *resultobj = 0;
25153 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25154 bool result;
25155 void *argp1 = 0 ;
25156 int res1 = 0 ;
25157 PyObject *swig_obj[1] ;
25158
25159 if (!args) SWIG_fail;
25160 swig_obj[0] = args;
25161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25162 if (!SWIG_IsOK(res1)) {
25163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25164 }
25165 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25166 {
25167 PyThreadState* __tstate = wxPyBeginAllowThreads();
25168 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25169 wxPyEndAllowThreads(__tstate);
25170 if (PyErr_Occurred()) SWIG_fail;
25171 }
25172 {
25173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25174 }
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25182 PyObject *resultobj = 0;
25183 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25184 bool result;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 PyObject *swig_obj[1] ;
25188
25189 if (!args) SWIG_fail;
25190 swig_obj[0] = args;
25191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25192 if (!SWIG_IsOK(res1)) {
25193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25194 }
25195 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25199 wxPyEndAllowThreads(__tstate);
25200 if (PyErr_Occurred()) SWIG_fail;
25201 }
25202 {
25203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25204 }
25205 return resultobj;
25206 fail:
25207 return NULL;
25208 }
25209
25210
25211 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25212 PyObject *resultobj = 0;
25213 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25214 bool result;
25215 void *argp1 = 0 ;
25216 int res1 = 0 ;
25217 PyObject *swig_obj[1] ;
25218
25219 if (!args) SWIG_fail;
25220 swig_obj[0] = args;
25221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25222 if (!SWIG_IsOK(res1)) {
25223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25224 }
25225 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25226 {
25227 PyThreadState* __tstate = wxPyBeginAllowThreads();
25228 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 {
25233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25234 }
25235 return resultobj;
25236 fail:
25237 return NULL;
25238 }
25239
25240
25241 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25242 PyObject *resultobj = 0;
25243 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25244 bool arg2 ;
25245 void *argp1 = 0 ;
25246 int res1 = 0 ;
25247 bool val2 ;
25248 int ecode2 = 0 ;
25249 PyObject * obj0 = 0 ;
25250 PyObject * obj1 = 0 ;
25251 char * kwnames[] = {
25252 (char *) "self",(char *) "check", NULL
25253 };
25254
25255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25257 if (!SWIG_IsOK(res1)) {
25258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25259 }
25260 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25262 if (!SWIG_IsOK(ecode2)) {
25263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25264 }
25265 arg2 = static_cast< bool >(val2);
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 (arg1)->Check(arg2);
25269 wxPyEndAllowThreads(__tstate);
25270 if (PyErr_Occurred()) SWIG_fail;
25271 }
25272 resultobj = SWIG_Py_Void();
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25280 PyObject *resultobj = 0;
25281 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25282 bool arg2 ;
25283 void *argp1 = 0 ;
25284 int res1 = 0 ;
25285 bool val2 ;
25286 int ecode2 = 0 ;
25287 PyObject * obj0 = 0 ;
25288 PyObject * obj1 = 0 ;
25289 char * kwnames[] = {
25290 (char *) "self",(char *) "enable", NULL
25291 };
25292
25293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25295 if (!SWIG_IsOK(res1)) {
25296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25297 }
25298 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25299 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25300 if (!SWIG_IsOK(ecode2)) {
25301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25302 }
25303 arg2 = static_cast< bool >(val2);
25304 {
25305 PyThreadState* __tstate = wxPyBeginAllowThreads();
25306 (arg1)->Enable(arg2);
25307 wxPyEndAllowThreads(__tstate);
25308 if (PyErr_Occurred()) SWIG_fail;
25309 }
25310 resultobj = SWIG_Py_Void();
25311 return resultobj;
25312 fail:
25313 return NULL;
25314 }
25315
25316
25317 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25318 PyObject *resultobj = 0;
25319 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25320 bool arg2 ;
25321 void *argp1 = 0 ;
25322 int res1 = 0 ;
25323 bool val2 ;
25324 int ecode2 = 0 ;
25325 PyObject * obj0 = 0 ;
25326 PyObject * obj1 = 0 ;
25327 char * kwnames[] = {
25328 (char *) "self",(char *) "show", NULL
25329 };
25330
25331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25333 if (!SWIG_IsOK(res1)) {
25334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25335 }
25336 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25337 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25338 if (!SWIG_IsOK(ecode2)) {
25339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25340 }
25341 arg2 = static_cast< bool >(val2);
25342 {
25343 PyThreadState* __tstate = wxPyBeginAllowThreads();
25344 (arg1)->Show(arg2);
25345 wxPyEndAllowThreads(__tstate);
25346 if (PyErr_Occurred()) SWIG_fail;
25347 }
25348 resultobj = SWIG_Py_Void();
25349 return resultobj;
25350 fail:
25351 return NULL;
25352 }
25353
25354
25355 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25356 PyObject *resultobj = 0;
25357 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25358 wxString *arg2 = 0 ;
25359 void *argp1 = 0 ;
25360 int res1 = 0 ;
25361 bool temp2 = false ;
25362 PyObject * obj0 = 0 ;
25363 PyObject * obj1 = 0 ;
25364 char * kwnames[] = {
25365 (char *) "self",(char *) "text", NULL
25366 };
25367
25368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25370 if (!SWIG_IsOK(res1)) {
25371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25372 }
25373 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25374 {
25375 arg2 = wxString_in_helper(obj1);
25376 if (arg2 == NULL) SWIG_fail;
25377 temp2 = true;
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 (arg1)->SetText((wxString const &)*arg2);
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_Py_Void();
25386 {
25387 if (temp2)
25388 delete arg2;
25389 }
25390 return resultobj;
25391 fail:
25392 {
25393 if (temp2)
25394 delete arg2;
25395 }
25396 return NULL;
25397 }
25398
25399
25400 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj = 0;
25402 long arg1 ;
25403 long val1 ;
25404 int ecode1 = 0 ;
25405 PyObject * obj0 = 0 ;
25406 char * kwnames[] = {
25407 (char *) "updateInterval", NULL
25408 };
25409
25410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25411 ecode1 = SWIG_AsVal_long(obj0, &val1);
25412 if (!SWIG_IsOK(ecode1)) {
25413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25414 }
25415 arg1 = static_cast< long >(val1);
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 wxUpdateUIEvent::SetUpdateInterval(arg1);
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 resultobj = SWIG_Py_Void();
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 PyObject *resultobj = 0;
25431 long result;
25432
25433 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25434 {
25435 PyThreadState* __tstate = wxPyBeginAllowThreads();
25436 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25437 wxPyEndAllowThreads(__tstate);
25438 if (PyErr_Occurred()) SWIG_fail;
25439 }
25440 resultobj = SWIG_From_long(static_cast< long >(result));
25441 return resultobj;
25442 fail:
25443 return NULL;
25444 }
25445
25446
25447 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25448 PyObject *resultobj = 0;
25449 wxWindow *arg1 = (wxWindow *) 0 ;
25450 bool result;
25451 void *argp1 = 0 ;
25452 int res1 = 0 ;
25453 PyObject * obj0 = 0 ;
25454 char * kwnames[] = {
25455 (char *) "win", NULL
25456 };
25457
25458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25460 if (!SWIG_IsOK(res1)) {
25461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25462 }
25463 arg1 = reinterpret_cast< wxWindow * >(argp1);
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 {
25471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25472 }
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25480 PyObject *resultobj = 0;
25481
25482 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25483 {
25484 PyThreadState* __tstate = wxPyBeginAllowThreads();
25485 wxUpdateUIEvent::ResetUpdateTime();
25486 wxPyEndAllowThreads(__tstate);
25487 if (PyErr_Occurred()) SWIG_fail;
25488 }
25489 resultobj = SWIG_Py_Void();
25490 return resultobj;
25491 fail:
25492 return NULL;
25493 }
25494
25495
25496 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25497 PyObject *resultobj = 0;
25498 wxUpdateUIMode arg1 ;
25499 int val1 ;
25500 int ecode1 = 0 ;
25501 PyObject * obj0 = 0 ;
25502 char * kwnames[] = {
25503 (char *) "mode", NULL
25504 };
25505
25506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25507 ecode1 = SWIG_AsVal_int(obj0, &val1);
25508 if (!SWIG_IsOK(ecode1)) {
25509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25510 }
25511 arg1 = static_cast< wxUpdateUIMode >(val1);
25512 {
25513 PyThreadState* __tstate = wxPyBeginAllowThreads();
25514 wxUpdateUIEvent::SetMode(arg1);
25515 wxPyEndAllowThreads(__tstate);
25516 if (PyErr_Occurred()) SWIG_fail;
25517 }
25518 resultobj = SWIG_Py_Void();
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25526 PyObject *resultobj = 0;
25527 wxUpdateUIMode result;
25528
25529 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25530 {
25531 PyThreadState* __tstate = wxPyBeginAllowThreads();
25532 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25533 wxPyEndAllowThreads(__tstate);
25534 if (PyErr_Occurred()) SWIG_fail;
25535 }
25536 resultobj = SWIG_From_int(static_cast< int >(result));
25537 return resultobj;
25538 fail:
25539 return NULL;
25540 }
25541
25542
25543 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25544 PyObject *obj;
25545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25546 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25547 return SWIG_Py_Void();
25548 }
25549
25550 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25551 return SWIG_Python_InitShadowInstance(args);
25552 }
25553
25554 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25555 PyObject *resultobj = 0;
25556 wxSysColourChangedEvent *result = 0 ;
25557
25558 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25573 PyObject *obj;
25574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25575 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25576 return SWIG_Py_Void();
25577 }
25578
25579 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 return SWIG_Python_InitShadowInstance(args);
25581 }
25582
25583 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25584 PyObject *resultobj = 0;
25585 int arg1 = (int) 0 ;
25586 wxWindow *arg2 = (wxWindow *) NULL ;
25587 wxMouseCaptureChangedEvent *result = 0 ;
25588 int val1 ;
25589 int ecode1 = 0 ;
25590 void *argp2 = 0 ;
25591 int res2 = 0 ;
25592 PyObject * obj0 = 0 ;
25593 PyObject * obj1 = 0 ;
25594 char * kwnames[] = {
25595 (char *) "winid",(char *) "gainedCapture", NULL
25596 };
25597
25598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25599 if (obj0) {
25600 ecode1 = SWIG_AsVal_int(obj0, &val1);
25601 if (!SWIG_IsOK(ecode1)) {
25602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25603 }
25604 arg1 = static_cast< int >(val1);
25605 }
25606 if (obj1) {
25607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25608 if (!SWIG_IsOK(res2)) {
25609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25610 }
25611 arg2 = reinterpret_cast< wxWindow * >(argp2);
25612 }
25613 {
25614 PyThreadState* __tstate = wxPyBeginAllowThreads();
25615 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25616 wxPyEndAllowThreads(__tstate);
25617 if (PyErr_Occurred()) SWIG_fail;
25618 }
25619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25620 return resultobj;
25621 fail:
25622 return NULL;
25623 }
25624
25625
25626 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25627 PyObject *resultobj = 0;
25628 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25629 wxWindow *result = 0 ;
25630 void *argp1 = 0 ;
25631 int res1 = 0 ;
25632 PyObject *swig_obj[1] ;
25633
25634 if (!args) SWIG_fail;
25635 swig_obj[0] = args;
25636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25637 if (!SWIG_IsOK(res1)) {
25638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25639 }
25640 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 {
25648 resultobj = wxPyMake_wxObject(result, (bool)0);
25649 }
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25657 PyObject *obj;
25658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25659 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25660 return SWIG_Py_Void();
25661 }
25662
25663 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25664 return SWIG_Python_InitShadowInstance(args);
25665 }
25666
25667 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj = 0;
25669 int arg1 = (int) 0 ;
25670 wxMouseCaptureLostEvent *result = 0 ;
25671 int val1 ;
25672 int ecode1 = 0 ;
25673 PyObject * obj0 = 0 ;
25674 char * kwnames[] = {
25675 (char *) "winid", NULL
25676 };
25677
25678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25679 if (obj0) {
25680 ecode1 = SWIG_AsVal_int(obj0, &val1);
25681 if (!SWIG_IsOK(ecode1)) {
25682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25683 }
25684 arg1 = static_cast< int >(val1);
25685 }
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25689 wxPyEndAllowThreads(__tstate);
25690 if (PyErr_Occurred()) SWIG_fail;
25691 }
25692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25693 return resultobj;
25694 fail:
25695 return NULL;
25696 }
25697
25698
25699 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25700 PyObject *obj;
25701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25702 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25703 return SWIG_Py_Void();
25704 }
25705
25706 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25707 return SWIG_Python_InitShadowInstance(args);
25708 }
25709
25710 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25711 PyObject *resultobj = 0;
25712 wxDisplayChangedEvent *result = 0 ;
25713
25714 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25715 {
25716 PyThreadState* __tstate = wxPyBeginAllowThreads();
25717 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25718 wxPyEndAllowThreads(__tstate);
25719 if (PyErr_Occurred()) SWIG_fail;
25720 }
25721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25722 return resultobj;
25723 fail:
25724 return NULL;
25725 }
25726
25727
25728 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25729 PyObject *obj;
25730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25731 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25732 return SWIG_Py_Void();
25733 }
25734
25735 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25736 return SWIG_Python_InitShadowInstance(args);
25737 }
25738
25739 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj = 0;
25741 int arg1 = (int) 0 ;
25742 wxPaletteChangedEvent *result = 0 ;
25743 int val1 ;
25744 int ecode1 = 0 ;
25745 PyObject * obj0 = 0 ;
25746 char * kwnames[] = {
25747 (char *) "id", NULL
25748 };
25749
25750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25751 if (obj0) {
25752 ecode1 = SWIG_AsVal_int(obj0, &val1);
25753 if (!SWIG_IsOK(ecode1)) {
25754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25755 }
25756 arg1 = static_cast< int >(val1);
25757 }
25758 {
25759 PyThreadState* __tstate = wxPyBeginAllowThreads();
25760 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25761 wxPyEndAllowThreads(__tstate);
25762 if (PyErr_Occurred()) SWIG_fail;
25763 }
25764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25772 PyObject *resultobj = 0;
25773 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25774 wxWindow *arg2 = (wxWindow *) 0 ;
25775 void *argp1 = 0 ;
25776 int res1 = 0 ;
25777 void *argp2 = 0 ;
25778 int res2 = 0 ;
25779 PyObject * obj0 = 0 ;
25780 PyObject * obj1 = 0 ;
25781 char * kwnames[] = {
25782 (char *) "self",(char *) "win", NULL
25783 };
25784
25785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25787 if (!SWIG_IsOK(res1)) {
25788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25789 }
25790 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25792 if (!SWIG_IsOK(res2)) {
25793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25794 }
25795 arg2 = reinterpret_cast< wxWindow * >(argp2);
25796 {
25797 PyThreadState* __tstate = wxPyBeginAllowThreads();
25798 (arg1)->SetChangedWindow(arg2);
25799 wxPyEndAllowThreads(__tstate);
25800 if (PyErr_Occurred()) SWIG_fail;
25801 }
25802 resultobj = SWIG_Py_Void();
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25810 PyObject *resultobj = 0;
25811 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25812 wxWindow *result = 0 ;
25813 void *argp1 = 0 ;
25814 int res1 = 0 ;
25815 PyObject *swig_obj[1] ;
25816
25817 if (!args) SWIG_fail;
25818 swig_obj[0] = args;
25819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25820 if (!SWIG_IsOK(res1)) {
25821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25822 }
25823 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25824 {
25825 PyThreadState* __tstate = wxPyBeginAllowThreads();
25826 result = (wxWindow *)(arg1)->GetChangedWindow();
25827 wxPyEndAllowThreads(__tstate);
25828 if (PyErr_Occurred()) SWIG_fail;
25829 }
25830 {
25831 resultobj = wxPyMake_wxObject(result, (bool)0);
25832 }
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25840 PyObject *obj;
25841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25842 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25843 return SWIG_Py_Void();
25844 }
25845
25846 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25847 return SWIG_Python_InitShadowInstance(args);
25848 }
25849
25850 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25851 PyObject *resultobj = 0;
25852 int arg1 = (int) 0 ;
25853 wxQueryNewPaletteEvent *result = 0 ;
25854 int val1 ;
25855 int ecode1 = 0 ;
25856 PyObject * obj0 = 0 ;
25857 char * kwnames[] = {
25858 (char *) "winid", NULL
25859 };
25860
25861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25862 if (obj0) {
25863 ecode1 = SWIG_AsVal_int(obj0, &val1);
25864 if (!SWIG_IsOK(ecode1)) {
25865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25866 }
25867 arg1 = static_cast< int >(val1);
25868 }
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25876 return resultobj;
25877 fail:
25878 return NULL;
25879 }
25880
25881
25882 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25883 PyObject *resultobj = 0;
25884 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25885 bool arg2 ;
25886 void *argp1 = 0 ;
25887 int res1 = 0 ;
25888 bool val2 ;
25889 int ecode2 = 0 ;
25890 PyObject * obj0 = 0 ;
25891 PyObject * obj1 = 0 ;
25892 char * kwnames[] = {
25893 (char *) "self",(char *) "realized", NULL
25894 };
25895
25896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25898 if (!SWIG_IsOK(res1)) {
25899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25900 }
25901 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25902 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25903 if (!SWIG_IsOK(ecode2)) {
25904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25905 }
25906 arg2 = static_cast< bool >(val2);
25907 {
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 (arg1)->SetPaletteRealized(arg2);
25910 wxPyEndAllowThreads(__tstate);
25911 if (PyErr_Occurred()) SWIG_fail;
25912 }
25913 resultobj = SWIG_Py_Void();
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25921 PyObject *resultobj = 0;
25922 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25923 bool result;
25924 void *argp1 = 0 ;
25925 int res1 = 0 ;
25926 PyObject *swig_obj[1] ;
25927
25928 if (!args) SWIG_fail;
25929 swig_obj[0] = args;
25930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25931 if (!SWIG_IsOK(res1)) {
25932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25933 }
25934 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25935 {
25936 PyThreadState* __tstate = wxPyBeginAllowThreads();
25937 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 {
25942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25943 }
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25951 PyObject *obj;
25952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25953 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25954 return SWIG_Py_Void();
25955 }
25956
25957 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25958 return SWIG_Python_InitShadowInstance(args);
25959 }
25960
25961 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25962 PyObject *resultobj = 0;
25963 wxNavigationKeyEvent *result = 0 ;
25964
25965 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25966 {
25967 PyThreadState* __tstate = wxPyBeginAllowThreads();
25968 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25969 wxPyEndAllowThreads(__tstate);
25970 if (PyErr_Occurred()) SWIG_fail;
25971 }
25972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25973 return resultobj;
25974 fail:
25975 return NULL;
25976 }
25977
25978
25979 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25980 PyObject *resultobj = 0;
25981 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25982 bool result;
25983 void *argp1 = 0 ;
25984 int res1 = 0 ;
25985 PyObject *swig_obj[1] ;
25986
25987 if (!args) SWIG_fail;
25988 swig_obj[0] = args;
25989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25990 if (!SWIG_IsOK(res1)) {
25991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25992 }
25993 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25997 wxPyEndAllowThreads(__tstate);
25998 if (PyErr_Occurred()) SWIG_fail;
25999 }
26000 {
26001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26002 }
26003 return resultobj;
26004 fail:
26005 return NULL;
26006 }
26007
26008
26009 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26010 PyObject *resultobj = 0;
26011 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26012 bool arg2 ;
26013 void *argp1 = 0 ;
26014 int res1 = 0 ;
26015 bool val2 ;
26016 int ecode2 = 0 ;
26017 PyObject * obj0 = 0 ;
26018 PyObject * obj1 = 0 ;
26019 char * kwnames[] = {
26020 (char *) "self",(char *) "forward", NULL
26021 };
26022
26023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26025 if (!SWIG_IsOK(res1)) {
26026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26027 }
26028 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26030 if (!SWIG_IsOK(ecode2)) {
26031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26032 }
26033 arg2 = static_cast< bool >(val2);
26034 {
26035 PyThreadState* __tstate = wxPyBeginAllowThreads();
26036 (arg1)->SetDirection(arg2);
26037 wxPyEndAllowThreads(__tstate);
26038 if (PyErr_Occurred()) SWIG_fail;
26039 }
26040 resultobj = SWIG_Py_Void();
26041 return resultobj;
26042 fail:
26043 return NULL;
26044 }
26045
26046
26047 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26048 PyObject *resultobj = 0;
26049 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26050 bool result;
26051 void *argp1 = 0 ;
26052 int res1 = 0 ;
26053 PyObject *swig_obj[1] ;
26054
26055 if (!args) SWIG_fail;
26056 swig_obj[0] = args;
26057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26058 if (!SWIG_IsOK(res1)) {
26059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26060 }
26061 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26062 {
26063 PyThreadState* __tstate = wxPyBeginAllowThreads();
26064 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26065 wxPyEndAllowThreads(__tstate);
26066 if (PyErr_Occurred()) SWIG_fail;
26067 }
26068 {
26069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26070 }
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26078 PyObject *resultobj = 0;
26079 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26080 bool arg2 ;
26081 void *argp1 = 0 ;
26082 int res1 = 0 ;
26083 bool val2 ;
26084 int ecode2 = 0 ;
26085 PyObject * obj0 = 0 ;
26086 PyObject * obj1 = 0 ;
26087 char * kwnames[] = {
26088 (char *) "self",(char *) "ischange", NULL
26089 };
26090
26091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26093 if (!SWIG_IsOK(res1)) {
26094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26095 }
26096 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26098 if (!SWIG_IsOK(ecode2)) {
26099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26100 }
26101 arg2 = static_cast< bool >(val2);
26102 {
26103 PyThreadState* __tstate = wxPyBeginAllowThreads();
26104 (arg1)->SetWindowChange(arg2);
26105 wxPyEndAllowThreads(__tstate);
26106 if (PyErr_Occurred()) SWIG_fail;
26107 }
26108 resultobj = SWIG_Py_Void();
26109 return resultobj;
26110 fail:
26111 return NULL;
26112 }
26113
26114
26115 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26116 PyObject *resultobj = 0;
26117 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26118 bool result;
26119 void *argp1 = 0 ;
26120 int res1 = 0 ;
26121 PyObject *swig_obj[1] ;
26122
26123 if (!args) SWIG_fail;
26124 swig_obj[0] = args;
26125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26126 if (!SWIG_IsOK(res1)) {
26127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26128 }
26129 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26130 {
26131 PyThreadState* __tstate = wxPyBeginAllowThreads();
26132 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26133 wxPyEndAllowThreads(__tstate);
26134 if (PyErr_Occurred()) SWIG_fail;
26135 }
26136 {
26137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26138 }
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj = 0;
26147 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26148 bool arg2 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 bool val2 ;
26152 int ecode2 = 0 ;
26153 PyObject * obj0 = 0 ;
26154 PyObject * obj1 = 0 ;
26155 char * kwnames[] = {
26156 (char *) "self",(char *) "bIs", NULL
26157 };
26158
26159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26163 }
26164 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26165 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26166 if (!SWIG_IsOK(ecode2)) {
26167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26168 }
26169 arg2 = static_cast< bool >(val2);
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 (arg1)->SetFromTab(arg2);
26173 wxPyEndAllowThreads(__tstate);
26174 if (PyErr_Occurred()) SWIG_fail;
26175 }
26176 resultobj = SWIG_Py_Void();
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26184 PyObject *resultobj = 0;
26185 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26186 long arg2 ;
26187 void *argp1 = 0 ;
26188 int res1 = 0 ;
26189 long val2 ;
26190 int ecode2 = 0 ;
26191 PyObject * obj0 = 0 ;
26192 PyObject * obj1 = 0 ;
26193 char * kwnames[] = {
26194 (char *) "self",(char *) "flags", NULL
26195 };
26196
26197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26199 if (!SWIG_IsOK(res1)) {
26200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26201 }
26202 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26203 ecode2 = SWIG_AsVal_long(obj1, &val2);
26204 if (!SWIG_IsOK(ecode2)) {
26205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26206 }
26207 arg2 = static_cast< long >(val2);
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 (arg1)->SetFlags(arg2);
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 resultobj = SWIG_Py_Void();
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 PyObject *resultobj = 0;
26223 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26224 wxWindow *result = 0 ;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 PyObject *swig_obj[1] ;
26228
26229 if (!args) SWIG_fail;
26230 swig_obj[0] = args;
26231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26232 if (!SWIG_IsOK(res1)) {
26233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26234 }
26235 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26236 {
26237 PyThreadState* __tstate = wxPyBeginAllowThreads();
26238 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 {
26243 resultobj = wxPyMake_wxObject(result, (bool)0);
26244 }
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26252 PyObject *resultobj = 0;
26253 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26254 wxWindow *arg2 = (wxWindow *) 0 ;
26255 void *argp1 = 0 ;
26256 int res1 = 0 ;
26257 void *argp2 = 0 ;
26258 int res2 = 0 ;
26259 PyObject * obj0 = 0 ;
26260 PyObject * obj1 = 0 ;
26261 char * kwnames[] = {
26262 (char *) "self",(char *) "win", NULL
26263 };
26264
26265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26267 if (!SWIG_IsOK(res1)) {
26268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26269 }
26270 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26272 if (!SWIG_IsOK(res2)) {
26273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26274 }
26275 arg2 = reinterpret_cast< wxWindow * >(argp2);
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 (arg1)->SetCurrentFocus(arg2);
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_Py_Void();
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *obj;
26291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26292 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26293 return SWIG_Py_Void();
26294 }
26295
26296 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 return SWIG_Python_InitShadowInstance(args);
26298 }
26299
26300 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26301 PyObject *resultobj = 0;
26302 wxWindow *arg1 = (wxWindow *) NULL ;
26303 wxWindowCreateEvent *result = 0 ;
26304 void *argp1 = 0 ;
26305 int res1 = 0 ;
26306 PyObject * obj0 = 0 ;
26307 char * kwnames[] = {
26308 (char *) "win", NULL
26309 };
26310
26311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26312 if (obj0) {
26313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26314 if (!SWIG_IsOK(res1)) {
26315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26316 }
26317 arg1 = reinterpret_cast< wxWindow * >(argp1);
26318 }
26319 {
26320 PyThreadState* __tstate = wxPyBeginAllowThreads();
26321 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26322 wxPyEndAllowThreads(__tstate);
26323 if (PyErr_Occurred()) SWIG_fail;
26324 }
26325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26326 return resultobj;
26327 fail:
26328 return NULL;
26329 }
26330
26331
26332 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26333 PyObject *resultobj = 0;
26334 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26335 wxWindow *result = 0 ;
26336 void *argp1 = 0 ;
26337 int res1 = 0 ;
26338 PyObject *swig_obj[1] ;
26339
26340 if (!args) SWIG_fail;
26341 swig_obj[0] = args;
26342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26343 if (!SWIG_IsOK(res1)) {
26344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26345 }
26346 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26347 {
26348 PyThreadState* __tstate = wxPyBeginAllowThreads();
26349 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26350 wxPyEndAllowThreads(__tstate);
26351 if (PyErr_Occurred()) SWIG_fail;
26352 }
26353 {
26354 resultobj = wxPyMake_wxObject(result, (bool)0);
26355 }
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26363 PyObject *obj;
26364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26365 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26366 return SWIG_Py_Void();
26367 }
26368
26369 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26370 return SWIG_Python_InitShadowInstance(args);
26371 }
26372
26373 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26374 PyObject *resultobj = 0;
26375 wxWindow *arg1 = (wxWindow *) NULL ;
26376 wxWindowDestroyEvent *result = 0 ;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 PyObject * obj0 = 0 ;
26380 char * kwnames[] = {
26381 (char *) "win", NULL
26382 };
26383
26384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26385 if (obj0) {
26386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26387 if (!SWIG_IsOK(res1)) {
26388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26389 }
26390 arg1 = reinterpret_cast< wxWindow * >(argp1);
26391 }
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26406 PyObject *resultobj = 0;
26407 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26408 wxWindow *result = 0 ;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 PyObject *swig_obj[1] ;
26412
26413 if (!args) SWIG_fail;
26414 swig_obj[0] = args;
26415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26416 if (!SWIG_IsOK(res1)) {
26417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26418 }
26419 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 {
26427 resultobj = wxPyMake_wxObject(result, (bool)0);
26428 }
26429 return resultobj;
26430 fail:
26431 return NULL;
26432 }
26433
26434
26435 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26436 PyObject *obj;
26437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26438 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26439 return SWIG_Py_Void();
26440 }
26441
26442 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26443 return SWIG_Python_InitShadowInstance(args);
26444 }
26445
26446 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26447 PyObject *resultobj = 0;
26448 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26449 int arg2 = (int) 0 ;
26450 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26451 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26452 wxContextMenuEvent *result = 0 ;
26453 int val1 ;
26454 int ecode1 = 0 ;
26455 int val2 ;
26456 int ecode2 = 0 ;
26457 wxPoint temp3 ;
26458 PyObject * obj0 = 0 ;
26459 PyObject * obj1 = 0 ;
26460 PyObject * obj2 = 0 ;
26461 char * kwnames[] = {
26462 (char *) "type",(char *) "winid",(char *) "pt", NULL
26463 };
26464
26465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26466 if (obj0) {
26467 ecode1 = SWIG_AsVal_int(obj0, &val1);
26468 if (!SWIG_IsOK(ecode1)) {
26469 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26470 }
26471 arg1 = static_cast< wxEventType >(val1);
26472 }
26473 if (obj1) {
26474 ecode2 = SWIG_AsVal_int(obj1, &val2);
26475 if (!SWIG_IsOK(ecode2)) {
26476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26477 }
26478 arg2 = static_cast< int >(val2);
26479 }
26480 if (obj2) {
26481 {
26482 arg3 = &temp3;
26483 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26484 }
26485 }
26486 {
26487 PyThreadState* __tstate = wxPyBeginAllowThreads();
26488 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26493 return resultobj;
26494 fail:
26495 return NULL;
26496 }
26497
26498
26499 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26500 PyObject *resultobj = 0;
26501 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26502 wxPoint *result = 0 ;
26503 void *argp1 = 0 ;
26504 int res1 = 0 ;
26505 PyObject *swig_obj[1] ;
26506
26507 if (!args) SWIG_fail;
26508 swig_obj[0] = args;
26509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26510 if (!SWIG_IsOK(res1)) {
26511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26512 }
26513 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26514 {
26515 PyThreadState* __tstate = wxPyBeginAllowThreads();
26516 {
26517 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26518 result = (wxPoint *) &_result_ref;
26519 }
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj = 0;
26532 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26533 wxPoint *arg2 = 0 ;
26534 void *argp1 = 0 ;
26535 int res1 = 0 ;
26536 wxPoint temp2 ;
26537 PyObject * obj0 = 0 ;
26538 PyObject * obj1 = 0 ;
26539 char * kwnames[] = {
26540 (char *) "self",(char *) "pos", NULL
26541 };
26542
26543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26545 if (!SWIG_IsOK(res1)) {
26546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26547 }
26548 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26549 {
26550 arg2 = &temp2;
26551 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26552 }
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 (arg1)->SetPosition((wxPoint const &)*arg2);
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 resultobj = SWIG_Py_Void();
26560 return resultobj;
26561 fail:
26562 return NULL;
26563 }
26564
26565
26566 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26567 PyObject *obj;
26568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26569 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26570 return SWIG_Py_Void();
26571 }
26572
26573 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26574 return SWIG_Python_InitShadowInstance(args);
26575 }
26576
26577 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26578 PyObject *resultobj = 0;
26579 wxIdleEvent *result = 0 ;
26580
26581 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26582 {
26583 PyThreadState* __tstate = wxPyBeginAllowThreads();
26584 result = (wxIdleEvent *)new wxIdleEvent();
26585 wxPyEndAllowThreads(__tstate);
26586 if (PyErr_Occurred()) SWIG_fail;
26587 }
26588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26589 return resultobj;
26590 fail:
26591 return NULL;
26592 }
26593
26594
26595 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj = 0;
26597 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26598 bool arg2 = (bool) true ;
26599 void *argp1 = 0 ;
26600 int res1 = 0 ;
26601 bool val2 ;
26602 int ecode2 = 0 ;
26603 PyObject * obj0 = 0 ;
26604 PyObject * obj1 = 0 ;
26605 char * kwnames[] = {
26606 (char *) "self",(char *) "needMore", NULL
26607 };
26608
26609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26611 if (!SWIG_IsOK(res1)) {
26612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26613 }
26614 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26615 if (obj1) {
26616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26617 if (!SWIG_IsOK(ecode2)) {
26618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26619 }
26620 arg2 = static_cast< bool >(val2);
26621 }
26622 {
26623 PyThreadState* __tstate = wxPyBeginAllowThreads();
26624 (arg1)->RequestMore(arg2);
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 resultobj = SWIG_Py_Void();
26629 return resultobj;
26630 fail:
26631 return NULL;
26632 }
26633
26634
26635 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26636 PyObject *resultobj = 0;
26637 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26638 bool result;
26639 void *argp1 = 0 ;
26640 int res1 = 0 ;
26641 PyObject *swig_obj[1] ;
26642
26643 if (!args) SWIG_fail;
26644 swig_obj[0] = args;
26645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26646 if (!SWIG_IsOK(res1)) {
26647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26648 }
26649 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26650 {
26651 PyThreadState* __tstate = wxPyBeginAllowThreads();
26652 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26653 wxPyEndAllowThreads(__tstate);
26654 if (PyErr_Occurred()) SWIG_fail;
26655 }
26656 {
26657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26658 }
26659 return resultobj;
26660 fail:
26661 return NULL;
26662 }
26663
26664
26665 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26666 PyObject *resultobj = 0;
26667 wxIdleMode arg1 ;
26668 int val1 ;
26669 int ecode1 = 0 ;
26670 PyObject * obj0 = 0 ;
26671 char * kwnames[] = {
26672 (char *) "mode", NULL
26673 };
26674
26675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26676 ecode1 = SWIG_AsVal_int(obj0, &val1);
26677 if (!SWIG_IsOK(ecode1)) {
26678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26679 }
26680 arg1 = static_cast< wxIdleMode >(val1);
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 wxIdleEvent::SetMode(arg1);
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 resultobj = SWIG_Py_Void();
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26695 PyObject *resultobj = 0;
26696 wxIdleMode result;
26697
26698 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 result = (wxIdleMode)wxIdleEvent::GetMode();
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 resultobj = SWIG_From_int(static_cast< int >(result));
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26713 PyObject *resultobj = 0;
26714 wxWindow *arg1 = (wxWindow *) 0 ;
26715 bool result;
26716 void *argp1 = 0 ;
26717 int res1 = 0 ;
26718 PyObject * obj0 = 0 ;
26719 char * kwnames[] = {
26720 (char *) "win", NULL
26721 };
26722
26723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26725 if (!SWIG_IsOK(res1)) {
26726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26727 }
26728 arg1 = reinterpret_cast< wxWindow * >(argp1);
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 result = (bool)wxIdleEvent::CanSend(arg1);
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 {
26736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26737 }
26738 return resultobj;
26739 fail:
26740 return NULL;
26741 }
26742
26743
26744 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26745 PyObject *obj;
26746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26747 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26748 return SWIG_Py_Void();
26749 }
26750
26751 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26752 return SWIG_Python_InitShadowInstance(args);
26753 }
26754
26755 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj = 0;
26757 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26758 int arg2 = (int) 0 ;
26759 wxClipboardTextEvent *result = 0 ;
26760 int val1 ;
26761 int ecode1 = 0 ;
26762 int val2 ;
26763 int ecode2 = 0 ;
26764 PyObject * obj0 = 0 ;
26765 PyObject * obj1 = 0 ;
26766 char * kwnames[] = {
26767 (char *) "type",(char *) "winid", NULL
26768 };
26769
26770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26771 if (obj0) {
26772 ecode1 = SWIG_AsVal_int(obj0, &val1);
26773 if (!SWIG_IsOK(ecode1)) {
26774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26775 }
26776 arg1 = static_cast< wxEventType >(val1);
26777 }
26778 if (obj1) {
26779 ecode2 = SWIG_AsVal_int(obj1, &val2);
26780 if (!SWIG_IsOK(ecode2)) {
26781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26782 }
26783 arg2 = static_cast< int >(val2);
26784 }
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26792 return resultobj;
26793 fail:
26794 return NULL;
26795 }
26796
26797
26798 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26799 PyObject *obj;
26800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26801 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26802 return SWIG_Py_Void();
26803 }
26804
26805 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26806 return SWIG_Python_InitShadowInstance(args);
26807 }
26808
26809 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26810 PyObject *resultobj = 0;
26811 int arg1 = (int) 0 ;
26812 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26813 wxPyEvent *result = 0 ;
26814 int val1 ;
26815 int ecode1 = 0 ;
26816 int val2 ;
26817 int ecode2 = 0 ;
26818 PyObject * obj0 = 0 ;
26819 PyObject * obj1 = 0 ;
26820 char * kwnames[] = {
26821 (char *) "winid",(char *) "eventType", NULL
26822 };
26823
26824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26825 if (obj0) {
26826 ecode1 = SWIG_AsVal_int(obj0, &val1);
26827 if (!SWIG_IsOK(ecode1)) {
26828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26829 }
26830 arg1 = static_cast< int >(val1);
26831 }
26832 if (obj1) {
26833 ecode2 = SWIG_AsVal_int(obj1, &val2);
26834 if (!SWIG_IsOK(ecode2)) {
26835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26836 }
26837 arg2 = static_cast< wxEventType >(val2);
26838 }
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26842 wxPyEndAllowThreads(__tstate);
26843 if (PyErr_Occurred()) SWIG_fail;
26844 }
26845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26853 PyObject *resultobj = 0;
26854 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26855 void *argp1 = 0 ;
26856 int res1 = 0 ;
26857 PyObject *swig_obj[1] ;
26858
26859 if (!args) SWIG_fail;
26860 swig_obj[0] = args;
26861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26862 if (!SWIG_IsOK(res1)) {
26863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26864 }
26865 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26866 {
26867 PyThreadState* __tstate = wxPyBeginAllowThreads();
26868 delete arg1;
26869
26870 wxPyEndAllowThreads(__tstate);
26871 if (PyErr_Occurred()) SWIG_fail;
26872 }
26873 resultobj = SWIG_Py_Void();
26874 return resultobj;
26875 fail:
26876 return NULL;
26877 }
26878
26879
26880 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26881 PyObject *resultobj = 0;
26882 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26883 PyObject *arg2 = (PyObject *) 0 ;
26884 void *argp1 = 0 ;
26885 int res1 = 0 ;
26886 PyObject * obj0 = 0 ;
26887 PyObject * obj1 = 0 ;
26888 char * kwnames[] = {
26889 (char *) "self",(char *) "self", NULL
26890 };
26891
26892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26894 if (!SWIG_IsOK(res1)) {
26895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26896 }
26897 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26898 arg2 = obj1;
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 (arg1)->SetSelf(arg2);
26902 wxPyEndAllowThreads(__tstate);
26903 if (PyErr_Occurred()) SWIG_fail;
26904 }
26905 resultobj = SWIG_Py_Void();
26906 return resultobj;
26907 fail:
26908 return NULL;
26909 }
26910
26911
26912 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26913 PyObject *resultobj = 0;
26914 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26915 PyObject *result = 0 ;
26916 void *argp1 = 0 ;
26917 int res1 = 0 ;
26918 PyObject *swig_obj[1] ;
26919
26920 if (!args) SWIG_fail;
26921 swig_obj[0] = args;
26922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26923 if (!SWIG_IsOK(res1)) {
26924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26925 }
26926 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 result = (PyObject *)(arg1)->GetSelf();
26930 wxPyEndAllowThreads(__tstate);
26931 if (PyErr_Occurred()) SWIG_fail;
26932 }
26933 resultobj = result;
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26941 PyObject *obj;
26942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26943 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26944 return SWIG_Py_Void();
26945 }
26946
26947 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 return SWIG_Python_InitShadowInstance(args);
26949 }
26950
26951 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26952 PyObject *resultobj = 0;
26953 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26954 int arg2 = (int) 0 ;
26955 wxPyCommandEvent *result = 0 ;
26956 int val1 ;
26957 int ecode1 = 0 ;
26958 int val2 ;
26959 int ecode2 = 0 ;
26960 PyObject * obj0 = 0 ;
26961 PyObject * obj1 = 0 ;
26962 char * kwnames[] = {
26963 (char *) "eventType",(char *) "id", NULL
26964 };
26965
26966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26967 if (obj0) {
26968 ecode1 = SWIG_AsVal_int(obj0, &val1);
26969 if (!SWIG_IsOK(ecode1)) {
26970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26971 }
26972 arg1 = static_cast< wxEventType >(val1);
26973 }
26974 if (obj1) {
26975 ecode2 = SWIG_AsVal_int(obj1, &val2);
26976 if (!SWIG_IsOK(ecode2)) {
26977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26978 }
26979 arg2 = static_cast< int >(val2);
26980 }
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26988 return resultobj;
26989 fail:
26990 return NULL;
26991 }
26992
26993
26994 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26995 PyObject *resultobj = 0;
26996 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26997 void *argp1 = 0 ;
26998 int res1 = 0 ;
26999 PyObject *swig_obj[1] ;
27000
27001 if (!args) SWIG_fail;
27002 swig_obj[0] = args;
27003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27004 if (!SWIG_IsOK(res1)) {
27005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27006 }
27007 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 delete arg1;
27011
27012 wxPyEndAllowThreads(__tstate);
27013 if (PyErr_Occurred()) SWIG_fail;
27014 }
27015 resultobj = SWIG_Py_Void();
27016 return resultobj;
27017 fail:
27018 return NULL;
27019 }
27020
27021
27022 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27023 PyObject *resultobj = 0;
27024 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27025 PyObject *arg2 = (PyObject *) 0 ;
27026 void *argp1 = 0 ;
27027 int res1 = 0 ;
27028 PyObject * obj0 = 0 ;
27029 PyObject * obj1 = 0 ;
27030 char * kwnames[] = {
27031 (char *) "self",(char *) "self", NULL
27032 };
27033
27034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27036 if (!SWIG_IsOK(res1)) {
27037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27038 }
27039 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27040 arg2 = obj1;
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 (arg1)->SetSelf(arg2);
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 resultobj = SWIG_Py_Void();
27048 return resultobj;
27049 fail:
27050 return NULL;
27051 }
27052
27053
27054 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27055 PyObject *resultobj = 0;
27056 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27057 PyObject *result = 0 ;
27058 void *argp1 = 0 ;
27059 int res1 = 0 ;
27060 PyObject *swig_obj[1] ;
27061
27062 if (!args) SWIG_fail;
27063 swig_obj[0] = args;
27064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27065 if (!SWIG_IsOK(res1)) {
27066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27067 }
27068 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 result = (PyObject *)(arg1)->GetSelf();
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 resultobj = result;
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27083 PyObject *obj;
27084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27085 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27086 return SWIG_Py_Void();
27087 }
27088
27089 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27090 return SWIG_Python_InitShadowInstance(args);
27091 }
27092
27093 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj = 0;
27095 wxWindow *arg1 = (wxWindow *) 0 ;
27096 wxDateTime *arg2 = 0 ;
27097 wxEventType arg3 ;
27098 wxDateEvent *result = 0 ;
27099 void *argp1 = 0 ;
27100 int res1 = 0 ;
27101 void *argp2 = 0 ;
27102 int res2 = 0 ;
27103 int val3 ;
27104 int ecode3 = 0 ;
27105 PyObject * obj0 = 0 ;
27106 PyObject * obj1 = 0 ;
27107 PyObject * obj2 = 0 ;
27108 char * kwnames[] = {
27109 (char *) "win",(char *) "dt",(char *) "type", NULL
27110 };
27111
27112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27114 if (!SWIG_IsOK(res1)) {
27115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27116 }
27117 arg1 = reinterpret_cast< wxWindow * >(argp1);
27118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27119 if (!SWIG_IsOK(res2)) {
27120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27121 }
27122 if (!argp2) {
27123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27124 }
27125 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27126 ecode3 = SWIG_AsVal_int(obj2, &val3);
27127 if (!SWIG_IsOK(ecode3)) {
27128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27129 }
27130 arg3 = static_cast< wxEventType >(val3);
27131 {
27132 PyThreadState* __tstate = wxPyBeginAllowThreads();
27133 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27134 wxPyEndAllowThreads(__tstate);
27135 if (PyErr_Occurred()) SWIG_fail;
27136 }
27137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27138 return resultobj;
27139 fail:
27140 return NULL;
27141 }
27142
27143
27144 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27145 PyObject *resultobj = 0;
27146 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27147 wxDateTime *result = 0 ;
27148 void *argp1 = 0 ;
27149 int res1 = 0 ;
27150 PyObject *swig_obj[1] ;
27151
27152 if (!args) SWIG_fail;
27153 swig_obj[0] = args;
27154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27155 if (!SWIG_IsOK(res1)) {
27156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27157 }
27158 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27159 {
27160 PyThreadState* __tstate = wxPyBeginAllowThreads();
27161 {
27162 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27163 result = (wxDateTime *) &_result_ref;
27164 }
27165 wxPyEndAllowThreads(__tstate);
27166 if (PyErr_Occurred()) SWIG_fail;
27167 }
27168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27169 return resultobj;
27170 fail:
27171 return NULL;
27172 }
27173
27174
27175 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27176 PyObject *resultobj = 0;
27177 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27178 wxDateTime *arg2 = 0 ;
27179 void *argp1 = 0 ;
27180 int res1 = 0 ;
27181 void *argp2 = 0 ;
27182 int res2 = 0 ;
27183 PyObject * obj0 = 0 ;
27184 PyObject * obj1 = 0 ;
27185 char * kwnames[] = {
27186 (char *) "self",(char *) "date", NULL
27187 };
27188
27189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27191 if (!SWIG_IsOK(res1)) {
27192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27193 }
27194 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27196 if (!SWIG_IsOK(res2)) {
27197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27198 }
27199 if (!argp2) {
27200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27201 }
27202 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27203 {
27204 PyThreadState* __tstate = wxPyBeginAllowThreads();
27205 (arg1)->SetDate((wxDateTime const &)*arg2);
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 resultobj = SWIG_Py_Void();
27210 return resultobj;
27211 fail:
27212 return NULL;
27213 }
27214
27215
27216 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27217 PyObject *obj;
27218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27219 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27220 return SWIG_Py_Void();
27221 }
27222
27223 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 return SWIG_Python_InitShadowInstance(args);
27225 }
27226
27227 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27228 PyObject *resultobj = 0;
27229 wxPyApp *result = 0 ;
27230
27231 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (wxPyApp *)new_wxPyApp();
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27239 return resultobj;
27240 fail:
27241 return NULL;
27242 }
27243
27244
27245 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27246 PyObject *resultobj = 0;
27247 wxPyApp *arg1 = (wxPyApp *) 0 ;
27248 void *argp1 = 0 ;
27249 int res1 = 0 ;
27250 PyObject *swig_obj[1] ;
27251
27252 if (!args) SWIG_fail;
27253 swig_obj[0] = args;
27254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27255 if (!SWIG_IsOK(res1)) {
27256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27257 }
27258 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 delete arg1;
27262
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 resultobj = SWIG_Py_Void();
27267 return resultobj;
27268 fail:
27269 return NULL;
27270 }
27271
27272
27273 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27274 PyObject *resultobj = 0;
27275 wxPyApp *arg1 = (wxPyApp *) 0 ;
27276 PyObject *arg2 = (PyObject *) 0 ;
27277 PyObject *arg3 = (PyObject *) 0 ;
27278 bool arg4 ;
27279 void *argp1 = 0 ;
27280 int res1 = 0 ;
27281 bool val4 ;
27282 int ecode4 = 0 ;
27283 PyObject * obj0 = 0 ;
27284 PyObject * obj1 = 0 ;
27285 PyObject * obj2 = 0 ;
27286 PyObject * obj3 = 0 ;
27287 char * kwnames[] = {
27288 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27289 };
27290
27291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27293 if (!SWIG_IsOK(res1)) {
27294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27295 }
27296 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27297 arg2 = obj1;
27298 arg3 = obj2;
27299 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27300 if (!SWIG_IsOK(ecode4)) {
27301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27302 }
27303 arg4 = static_cast< bool >(val4);
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 resultobj = SWIG_Py_Void();
27311 return resultobj;
27312 fail:
27313 return NULL;
27314 }
27315
27316
27317 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27318 PyObject *resultobj = 0;
27319 wxPyApp *arg1 = (wxPyApp *) 0 ;
27320 wxString result;
27321 void *argp1 = 0 ;
27322 int res1 = 0 ;
27323 PyObject *swig_obj[1] ;
27324
27325 if (!args) SWIG_fail;
27326 swig_obj[0] = args;
27327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27328 if (!SWIG_IsOK(res1)) {
27329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27330 }
27331 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27332 {
27333 PyThreadState* __tstate = wxPyBeginAllowThreads();
27334 result = ((wxPyApp const *)arg1)->GetAppName();
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 {
27339 #if wxUSE_UNICODE
27340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27341 #else
27342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27343 #endif
27344 }
27345 return resultobj;
27346 fail:
27347 return NULL;
27348 }
27349
27350
27351 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27352 PyObject *resultobj = 0;
27353 wxPyApp *arg1 = (wxPyApp *) 0 ;
27354 wxString *arg2 = 0 ;
27355 void *argp1 = 0 ;
27356 int res1 = 0 ;
27357 bool temp2 = false ;
27358 PyObject * obj0 = 0 ;
27359 PyObject * obj1 = 0 ;
27360 char * kwnames[] = {
27361 (char *) "self",(char *) "name", NULL
27362 };
27363
27364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27366 if (!SWIG_IsOK(res1)) {
27367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27368 }
27369 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27370 {
27371 arg2 = wxString_in_helper(obj1);
27372 if (arg2 == NULL) SWIG_fail;
27373 temp2 = true;
27374 }
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 (arg1)->SetAppName((wxString const &)*arg2);
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 resultobj = SWIG_Py_Void();
27382 {
27383 if (temp2)
27384 delete arg2;
27385 }
27386 return resultobj;
27387 fail:
27388 {
27389 if (temp2)
27390 delete arg2;
27391 }
27392 return NULL;
27393 }
27394
27395
27396 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27397 PyObject *resultobj = 0;
27398 wxPyApp *arg1 = (wxPyApp *) 0 ;
27399 wxString result;
27400 void *argp1 = 0 ;
27401 int res1 = 0 ;
27402 PyObject *swig_obj[1] ;
27403
27404 if (!args) SWIG_fail;
27405 swig_obj[0] = args;
27406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27407 if (!SWIG_IsOK(res1)) {
27408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27409 }
27410 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 result = ((wxPyApp const *)arg1)->GetClassName();
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 {
27418 #if wxUSE_UNICODE
27419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27420 #else
27421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27422 #endif
27423 }
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj = 0;
27432 wxPyApp *arg1 = (wxPyApp *) 0 ;
27433 wxString *arg2 = 0 ;
27434 void *argp1 = 0 ;
27435 int res1 = 0 ;
27436 bool temp2 = false ;
27437 PyObject * obj0 = 0 ;
27438 PyObject * obj1 = 0 ;
27439 char * kwnames[] = {
27440 (char *) "self",(char *) "name", NULL
27441 };
27442
27443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27445 if (!SWIG_IsOK(res1)) {
27446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27447 }
27448 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27449 {
27450 arg2 = wxString_in_helper(obj1);
27451 if (arg2 == NULL) SWIG_fail;
27452 temp2 = true;
27453 }
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 (arg1)->SetClassName((wxString const &)*arg2);
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 resultobj = SWIG_Py_Void();
27461 {
27462 if (temp2)
27463 delete arg2;
27464 }
27465 return resultobj;
27466 fail:
27467 {
27468 if (temp2)
27469 delete arg2;
27470 }
27471 return NULL;
27472 }
27473
27474
27475 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27476 PyObject *resultobj = 0;
27477 wxPyApp *arg1 = (wxPyApp *) 0 ;
27478 wxString *result = 0 ;
27479 void *argp1 = 0 ;
27480 int res1 = 0 ;
27481 PyObject *swig_obj[1] ;
27482
27483 if (!args) SWIG_fail;
27484 swig_obj[0] = args;
27485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27486 if (!SWIG_IsOK(res1)) {
27487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27488 }
27489 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 {
27493 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27494 result = (wxString *) &_result_ref;
27495 }
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 {
27500 #if wxUSE_UNICODE
27501 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27502 #else
27503 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27504 #endif
27505 }
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = 0;
27514 wxPyApp *arg1 = (wxPyApp *) 0 ;
27515 wxString *arg2 = 0 ;
27516 void *argp1 = 0 ;
27517 int res1 = 0 ;
27518 bool temp2 = false ;
27519 PyObject * obj0 = 0 ;
27520 PyObject * obj1 = 0 ;
27521 char * kwnames[] = {
27522 (char *) "self",(char *) "name", NULL
27523 };
27524
27525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27527 if (!SWIG_IsOK(res1)) {
27528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27529 }
27530 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27531 {
27532 arg2 = wxString_in_helper(obj1);
27533 if (arg2 == NULL) SWIG_fail;
27534 temp2 = true;
27535 }
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 (arg1)->SetVendorName((wxString const &)*arg2);
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_Py_Void();
27543 {
27544 if (temp2)
27545 delete arg2;
27546 }
27547 return resultobj;
27548 fail:
27549 {
27550 if (temp2)
27551 delete arg2;
27552 }
27553 return NULL;
27554 }
27555
27556
27557 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27558 PyObject *resultobj = 0;
27559 wxPyApp *arg1 = (wxPyApp *) 0 ;
27560 wxAppTraits *result = 0 ;
27561 void *argp1 = 0 ;
27562 int res1 = 0 ;
27563 PyObject *swig_obj[1] ;
27564
27565 if (!args) SWIG_fail;
27566 swig_obj[0] = args;
27567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27568 if (!SWIG_IsOK(res1)) {
27569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27570 }
27571 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27572 {
27573 PyThreadState* __tstate = wxPyBeginAllowThreads();
27574 result = (wxAppTraits *)(arg1)->GetTraits();
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27586 PyObject *resultobj = 0;
27587 wxPyApp *arg1 = (wxPyApp *) 0 ;
27588 void *argp1 = 0 ;
27589 int res1 = 0 ;
27590 PyObject *swig_obj[1] ;
27591
27592 if (!args) SWIG_fail;
27593 swig_obj[0] = args;
27594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27595 if (!SWIG_IsOK(res1)) {
27596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27597 }
27598 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27599 {
27600 PyThreadState* __tstate = wxPyBeginAllowThreads();
27601 (arg1)->ProcessPendingEvents();
27602 wxPyEndAllowThreads(__tstate);
27603 if (PyErr_Occurred()) SWIG_fail;
27604 }
27605 resultobj = SWIG_Py_Void();
27606 return resultobj;
27607 fail:
27608 return NULL;
27609 }
27610
27611
27612 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27613 PyObject *resultobj = 0;
27614 wxPyApp *arg1 = (wxPyApp *) 0 ;
27615 bool arg2 = (bool) false ;
27616 bool result;
27617 void *argp1 = 0 ;
27618 int res1 = 0 ;
27619 bool val2 ;
27620 int ecode2 = 0 ;
27621 PyObject * obj0 = 0 ;
27622 PyObject * obj1 = 0 ;
27623 char * kwnames[] = {
27624 (char *) "self",(char *) "onlyIfNeeded", NULL
27625 };
27626
27627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27629 if (!SWIG_IsOK(res1)) {
27630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27631 }
27632 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27633 if (obj1) {
27634 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27635 if (!SWIG_IsOK(ecode2)) {
27636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27637 }
27638 arg2 = static_cast< bool >(val2);
27639 }
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 result = (bool)(arg1)->Yield(arg2);
27643 wxPyEndAllowThreads(__tstate);
27644 if (PyErr_Occurred()) SWIG_fail;
27645 }
27646 {
27647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27648 }
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27656 PyObject *resultobj = 0;
27657 wxPyApp *arg1 = (wxPyApp *) 0 ;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 PyObject *swig_obj[1] ;
27661
27662 if (!args) SWIG_fail;
27663 swig_obj[0] = args;
27664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27667 }
27668 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 (arg1)->WakeUpIdle();
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 resultobj = SWIG_Py_Void();
27676 return resultobj;
27677 fail:
27678 return NULL;
27679 }
27680
27681
27682 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27683 PyObject *resultobj = 0;
27684 bool result;
27685
27686 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27687 {
27688 PyThreadState* __tstate = wxPyBeginAllowThreads();
27689 result = (bool)wxPyApp::IsMainLoopRunning();
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 {
27694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27695 }
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27703 PyObject *resultobj = 0;
27704 wxPyApp *arg1 = (wxPyApp *) 0 ;
27705 int result;
27706 void *argp1 = 0 ;
27707 int res1 = 0 ;
27708 PyObject *swig_obj[1] ;
27709
27710 if (!args) SWIG_fail;
27711 swig_obj[0] = args;
27712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27713 if (!SWIG_IsOK(res1)) {
27714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27715 }
27716 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (int)(arg1)->MainLoop();
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 resultobj = SWIG_From_int(static_cast< int >(result));
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27731 PyObject *resultobj = 0;
27732 wxPyApp *arg1 = (wxPyApp *) 0 ;
27733 void *argp1 = 0 ;
27734 int res1 = 0 ;
27735 PyObject *swig_obj[1] ;
27736
27737 if (!args) SWIG_fail;
27738 swig_obj[0] = args;
27739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27740 if (!SWIG_IsOK(res1)) {
27741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27742 }
27743 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 (arg1)->Exit();
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 resultobj = SWIG_Py_Void();
27751 return resultobj;
27752 fail:
27753 return NULL;
27754 }
27755
27756
27757 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27758 PyObject *resultobj = 0;
27759 wxPyApp *arg1 = (wxPyApp *) 0 ;
27760 wxLayoutDirection result;
27761 void *argp1 = 0 ;
27762 int res1 = 0 ;
27763 PyObject *swig_obj[1] ;
27764
27765 if (!args) SWIG_fail;
27766 swig_obj[0] = args;
27767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27768 if (!SWIG_IsOK(res1)) {
27769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27770 }
27771 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = ((wxPyApp const *)arg1)->GetLayoutDirection();
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27786 PyObject *resultobj = 0;
27787 wxPyApp *arg1 = (wxPyApp *) 0 ;
27788 void *argp1 = 0 ;
27789 int res1 = 0 ;
27790 PyObject *swig_obj[1] ;
27791
27792 if (!args) SWIG_fail;
27793 swig_obj[0] = args;
27794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27795 if (!SWIG_IsOK(res1)) {
27796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27797 }
27798 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27799 {
27800 PyThreadState* __tstate = wxPyBeginAllowThreads();
27801 (arg1)->ExitMainLoop();
27802 wxPyEndAllowThreads(__tstate);
27803 if (PyErr_Occurred()) SWIG_fail;
27804 }
27805 resultobj = SWIG_Py_Void();
27806 return resultobj;
27807 fail:
27808 return NULL;
27809 }
27810
27811
27812 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27813 PyObject *resultobj = 0;
27814 wxPyApp *arg1 = (wxPyApp *) 0 ;
27815 bool result;
27816 void *argp1 = 0 ;
27817 int res1 = 0 ;
27818 PyObject *swig_obj[1] ;
27819
27820 if (!args) SWIG_fail;
27821 swig_obj[0] = args;
27822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27823 if (!SWIG_IsOK(res1)) {
27824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27825 }
27826 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27827 {
27828 PyThreadState* __tstate = wxPyBeginAllowThreads();
27829 result = (bool)(arg1)->Pending();
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 {
27834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27835 }
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27843 PyObject *resultobj = 0;
27844 wxPyApp *arg1 = (wxPyApp *) 0 ;
27845 bool result;
27846 void *argp1 = 0 ;
27847 int res1 = 0 ;
27848 PyObject *swig_obj[1] ;
27849
27850 if (!args) SWIG_fail;
27851 swig_obj[0] = args;
27852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27853 if (!SWIG_IsOK(res1)) {
27854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27855 }
27856 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27857 {
27858 PyThreadState* __tstate = wxPyBeginAllowThreads();
27859 result = (bool)(arg1)->Dispatch();
27860 wxPyEndAllowThreads(__tstate);
27861 if (PyErr_Occurred()) SWIG_fail;
27862 }
27863 {
27864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27865 }
27866 return resultobj;
27867 fail:
27868 return NULL;
27869 }
27870
27871
27872 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27873 PyObject *resultobj = 0;
27874 wxPyApp *arg1 = (wxPyApp *) 0 ;
27875 bool result;
27876 void *argp1 = 0 ;
27877 int res1 = 0 ;
27878 PyObject *swig_obj[1] ;
27879
27880 if (!args) SWIG_fail;
27881 swig_obj[0] = args;
27882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27883 if (!SWIG_IsOK(res1)) {
27884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27885 }
27886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27887 {
27888 PyThreadState* __tstate = wxPyBeginAllowThreads();
27889 result = (bool)(arg1)->ProcessIdle();
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 {
27894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj = 0;
27904 wxPyApp *arg1 = (wxPyApp *) 0 ;
27905 wxWindow *arg2 = (wxWindow *) 0 ;
27906 wxIdleEvent *arg3 = 0 ;
27907 bool result;
27908 void *argp1 = 0 ;
27909 int res1 = 0 ;
27910 void *argp2 = 0 ;
27911 int res2 = 0 ;
27912 void *argp3 = 0 ;
27913 int res3 = 0 ;
27914 PyObject * obj0 = 0 ;
27915 PyObject * obj1 = 0 ;
27916 PyObject * obj2 = 0 ;
27917 char * kwnames[] = {
27918 (char *) "self",(char *) "win",(char *) "event", NULL
27919 };
27920
27921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27923 if (!SWIG_IsOK(res1)) {
27924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27925 }
27926 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27927 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27928 if (!SWIG_IsOK(res2)) {
27929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27930 }
27931 arg2 = reinterpret_cast< wxWindow * >(argp2);
27932 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27933 if (!SWIG_IsOK(res3)) {
27934 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27935 }
27936 if (!argp3) {
27937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27938 }
27939 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27940 {
27941 PyThreadState* __tstate = wxPyBeginAllowThreads();
27942 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27943 wxPyEndAllowThreads(__tstate);
27944 if (PyErr_Occurred()) SWIG_fail;
27945 }
27946 {
27947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27948 }
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27956 PyObject *resultobj = 0;
27957 wxPyApp *arg1 = (wxPyApp *) 0 ;
27958 bool result;
27959 void *argp1 = 0 ;
27960 int res1 = 0 ;
27961 PyObject *swig_obj[1] ;
27962
27963 if (!args) SWIG_fail;
27964 swig_obj[0] = args;
27965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27966 if (!SWIG_IsOK(res1)) {
27967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27968 }
27969 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 result = (bool)((wxPyApp const *)arg1)->IsActive();
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 {
27977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27978 }
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj = 0;
27987 wxPyApp *arg1 = (wxPyApp *) 0 ;
27988 wxWindow *arg2 = (wxWindow *) 0 ;
27989 void *argp1 = 0 ;
27990 int res1 = 0 ;
27991 void *argp2 = 0 ;
27992 int res2 = 0 ;
27993 PyObject * obj0 = 0 ;
27994 PyObject * obj1 = 0 ;
27995 char * kwnames[] = {
27996 (char *) "self",(char *) "win", NULL
27997 };
27998
27999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28001 if (!SWIG_IsOK(res1)) {
28002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28003 }
28004 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28006 if (!SWIG_IsOK(res2)) {
28007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28008 }
28009 arg2 = reinterpret_cast< wxWindow * >(argp2);
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 (arg1)->SetTopWindow(arg2);
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 resultobj = SWIG_Py_Void();
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28024 PyObject *resultobj = 0;
28025 wxPyApp *arg1 = (wxPyApp *) 0 ;
28026 wxWindow *result = 0 ;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 PyObject *swig_obj[1] ;
28030
28031 if (!args) SWIG_fail;
28032 swig_obj[0] = args;
28033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28034 if (!SWIG_IsOK(res1)) {
28035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28036 }
28037 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28038 {
28039 PyThreadState* __tstate = wxPyBeginAllowThreads();
28040 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 {
28045 resultobj = wxPyMake_wxObject(result, (bool)0);
28046 }
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28054 PyObject *resultobj = 0;
28055 wxPyApp *arg1 = (wxPyApp *) 0 ;
28056 bool arg2 ;
28057 void *argp1 = 0 ;
28058 int res1 = 0 ;
28059 bool val2 ;
28060 int ecode2 = 0 ;
28061 PyObject * obj0 = 0 ;
28062 PyObject * obj1 = 0 ;
28063 char * kwnames[] = {
28064 (char *) "self",(char *) "flag", NULL
28065 };
28066
28067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28069 if (!SWIG_IsOK(res1)) {
28070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28071 }
28072 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28073 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28074 if (!SWIG_IsOK(ecode2)) {
28075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28076 }
28077 arg2 = static_cast< bool >(val2);
28078 {
28079 PyThreadState* __tstate = wxPyBeginAllowThreads();
28080 (arg1)->SetExitOnFrameDelete(arg2);
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 resultobj = SWIG_Py_Void();
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28092 PyObject *resultobj = 0;
28093 wxPyApp *arg1 = (wxPyApp *) 0 ;
28094 bool result;
28095 void *argp1 = 0 ;
28096 int res1 = 0 ;
28097 PyObject *swig_obj[1] ;
28098
28099 if (!args) SWIG_fail;
28100 swig_obj[0] = args;
28101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28102 if (!SWIG_IsOK(res1)) {
28103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28104 }
28105 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 {
28113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28122 PyObject *resultobj = 0;
28123 wxPyApp *arg1 = (wxPyApp *) 0 ;
28124 bool arg2 ;
28125 void *argp1 = 0 ;
28126 int res1 = 0 ;
28127 bool val2 ;
28128 int ecode2 = 0 ;
28129 PyObject * obj0 = 0 ;
28130 PyObject * obj1 = 0 ;
28131 char * kwnames[] = {
28132 (char *) "self",(char *) "flag", NULL
28133 };
28134
28135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28137 if (!SWIG_IsOK(res1)) {
28138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28139 }
28140 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28141 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28142 if (!SWIG_IsOK(ecode2)) {
28143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28144 }
28145 arg2 = static_cast< bool >(val2);
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 (arg1)->SetUseBestVisual(arg2);
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 resultobj = SWIG_Py_Void();
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28160 PyObject *resultobj = 0;
28161 wxPyApp *arg1 = (wxPyApp *) 0 ;
28162 bool result;
28163 void *argp1 = 0 ;
28164 int res1 = 0 ;
28165 PyObject *swig_obj[1] ;
28166
28167 if (!args) SWIG_fail;
28168 swig_obj[0] = args;
28169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28170 if (!SWIG_IsOK(res1)) {
28171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28172 }
28173 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 {
28181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28182 }
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28190 PyObject *resultobj = 0;
28191 wxPyApp *arg1 = (wxPyApp *) 0 ;
28192 int arg2 ;
28193 void *argp1 = 0 ;
28194 int res1 = 0 ;
28195 int val2 ;
28196 int ecode2 = 0 ;
28197 PyObject * obj0 = 0 ;
28198 PyObject * obj1 = 0 ;
28199 char * kwnames[] = {
28200 (char *) "self",(char *) "mode", NULL
28201 };
28202
28203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28205 if (!SWIG_IsOK(res1)) {
28206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28207 }
28208 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28209 ecode2 = SWIG_AsVal_int(obj1, &val2);
28210 if (!SWIG_IsOK(ecode2)) {
28211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28212 }
28213 arg2 = static_cast< int >(val2);
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 (arg1)->SetPrintMode(arg2);
28217 wxPyEndAllowThreads(__tstate);
28218 if (PyErr_Occurred()) SWIG_fail;
28219 }
28220 resultobj = SWIG_Py_Void();
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28228 PyObject *resultobj = 0;
28229 wxPyApp *arg1 = (wxPyApp *) 0 ;
28230 int result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 PyObject *swig_obj[1] ;
28234
28235 if (!args) SWIG_fail;
28236 swig_obj[0] = args;
28237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28238 if (!SWIG_IsOK(res1)) {
28239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28240 }
28241 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 resultobj = SWIG_From_int(static_cast< int >(result));
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28256 PyObject *resultobj = 0;
28257 wxPyApp *arg1 = (wxPyApp *) 0 ;
28258 int arg2 ;
28259 void *argp1 = 0 ;
28260 int res1 = 0 ;
28261 int val2 ;
28262 int ecode2 = 0 ;
28263 PyObject * obj0 = 0 ;
28264 PyObject * obj1 = 0 ;
28265 char * kwnames[] = {
28266 (char *) "self",(char *) "mode", NULL
28267 };
28268
28269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28271 if (!SWIG_IsOK(res1)) {
28272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28273 }
28274 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28275 ecode2 = SWIG_AsVal_int(obj1, &val2);
28276 if (!SWIG_IsOK(ecode2)) {
28277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28278 }
28279 arg2 = static_cast< int >(val2);
28280 {
28281 PyThreadState* __tstate = wxPyBeginAllowThreads();
28282 (arg1)->SetAssertMode(arg2);
28283 wxPyEndAllowThreads(__tstate);
28284 if (PyErr_Occurred()) SWIG_fail;
28285 }
28286 resultobj = SWIG_Py_Void();
28287 return resultobj;
28288 fail:
28289 return NULL;
28290 }
28291
28292
28293 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28294 PyObject *resultobj = 0;
28295 wxPyApp *arg1 = (wxPyApp *) 0 ;
28296 int result;
28297 void *argp1 = 0 ;
28298 int res1 = 0 ;
28299 PyObject *swig_obj[1] ;
28300
28301 if (!args) SWIG_fail;
28302 swig_obj[0] = args;
28303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28304 if (!SWIG_IsOK(res1)) {
28305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28306 }
28307 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 result = (int)(arg1)->GetAssertMode();
28311 wxPyEndAllowThreads(__tstate);
28312 if (PyErr_Occurred()) SWIG_fail;
28313 }
28314 resultobj = SWIG_From_int(static_cast< int >(result));
28315 return resultobj;
28316 fail:
28317 return NULL;
28318 }
28319
28320
28321 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28322 PyObject *resultobj = 0;
28323 bool result;
28324
28325 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28326 {
28327 PyThreadState* __tstate = wxPyBeginAllowThreads();
28328 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28329 wxPyEndAllowThreads(__tstate);
28330 if (PyErr_Occurred()) SWIG_fail;
28331 }
28332 {
28333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28334 }
28335 return resultobj;
28336 fail:
28337 return NULL;
28338 }
28339
28340
28341 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28342 PyObject *resultobj = 0;
28343 long result;
28344
28345 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28346 {
28347 PyThreadState* __tstate = wxPyBeginAllowThreads();
28348 result = (long)wxPyApp::GetMacAboutMenuItemId();
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 resultobj = SWIG_From_long(static_cast< long >(result));
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28360 PyObject *resultobj = 0;
28361 long result;
28362
28363 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28367 wxPyEndAllowThreads(__tstate);
28368 if (PyErr_Occurred()) SWIG_fail;
28369 }
28370 resultobj = SWIG_From_long(static_cast< long >(result));
28371 return resultobj;
28372 fail:
28373 return NULL;
28374 }
28375
28376
28377 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28378 PyObject *resultobj = 0;
28379 long result;
28380
28381 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = (long)wxPyApp::GetMacExitMenuItemId();
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 resultobj = SWIG_From_long(static_cast< long >(result));
28389 return resultobj;
28390 fail:
28391 return NULL;
28392 }
28393
28394
28395 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28396 PyObject *resultobj = 0;
28397 wxString result;
28398
28399 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 result = wxPyApp::GetMacHelpMenuTitleName();
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 {
28407 #if wxUSE_UNICODE
28408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28409 #else
28410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28411 #endif
28412 }
28413 return resultobj;
28414 fail:
28415 return NULL;
28416 }
28417
28418
28419 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28420 PyObject *resultobj = 0;
28421 bool arg1 ;
28422 bool val1 ;
28423 int ecode1 = 0 ;
28424 PyObject * obj0 = 0 ;
28425 char * kwnames[] = {
28426 (char *) "val", NULL
28427 };
28428
28429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28430 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28431 if (!SWIG_IsOK(ecode1)) {
28432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28433 }
28434 arg1 = static_cast< bool >(val1);
28435 {
28436 PyThreadState* __tstate = wxPyBeginAllowThreads();
28437 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28438 wxPyEndAllowThreads(__tstate);
28439 if (PyErr_Occurred()) SWIG_fail;
28440 }
28441 resultobj = SWIG_Py_Void();
28442 return resultobj;
28443 fail:
28444 return NULL;
28445 }
28446
28447
28448 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28449 PyObject *resultobj = 0;
28450 long arg1 ;
28451 long val1 ;
28452 int ecode1 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 char * kwnames[] = {
28455 (char *) "val", NULL
28456 };
28457
28458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28459 ecode1 = SWIG_AsVal_long(obj0, &val1);
28460 if (!SWIG_IsOK(ecode1)) {
28461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28462 }
28463 arg1 = static_cast< long >(val1);
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 wxPyApp::SetMacAboutMenuItemId(arg1);
28467 wxPyEndAllowThreads(__tstate);
28468 if (PyErr_Occurred()) SWIG_fail;
28469 }
28470 resultobj = SWIG_Py_Void();
28471 return resultobj;
28472 fail:
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28478 PyObject *resultobj = 0;
28479 long arg1 ;
28480 long val1 ;
28481 int ecode1 = 0 ;
28482 PyObject * obj0 = 0 ;
28483 char * kwnames[] = {
28484 (char *) "val", NULL
28485 };
28486
28487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28488 ecode1 = SWIG_AsVal_long(obj0, &val1);
28489 if (!SWIG_IsOK(ecode1)) {
28490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28491 }
28492 arg1 = static_cast< long >(val1);
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28496 wxPyEndAllowThreads(__tstate);
28497 if (PyErr_Occurred()) SWIG_fail;
28498 }
28499 resultobj = SWIG_Py_Void();
28500 return resultobj;
28501 fail:
28502 return NULL;
28503 }
28504
28505
28506 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28507 PyObject *resultobj = 0;
28508 long arg1 ;
28509 long val1 ;
28510 int ecode1 = 0 ;
28511 PyObject * obj0 = 0 ;
28512 char * kwnames[] = {
28513 (char *) "val", NULL
28514 };
28515
28516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28517 ecode1 = SWIG_AsVal_long(obj0, &val1);
28518 if (!SWIG_IsOK(ecode1)) {
28519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28520 }
28521 arg1 = static_cast< long >(val1);
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 wxPyApp::SetMacExitMenuItemId(arg1);
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 resultobj = SWIG_Py_Void();
28529 return resultobj;
28530 fail:
28531 return NULL;
28532 }
28533
28534
28535 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28536 PyObject *resultobj = 0;
28537 wxString *arg1 = 0 ;
28538 bool temp1 = false ;
28539 PyObject * obj0 = 0 ;
28540 char * kwnames[] = {
28541 (char *) "val", NULL
28542 };
28543
28544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28545 {
28546 arg1 = wxString_in_helper(obj0);
28547 if (arg1 == NULL) SWIG_fail;
28548 temp1 = true;
28549 }
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 resultobj = SWIG_Py_Void();
28557 {
28558 if (temp1)
28559 delete arg1;
28560 }
28561 return resultobj;
28562 fail:
28563 {
28564 if (temp1)
28565 delete arg1;
28566 }
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28572 PyObject *resultobj = 0;
28573 wxPyApp *arg1 = (wxPyApp *) 0 ;
28574 void *argp1 = 0 ;
28575 int res1 = 0 ;
28576 PyObject *swig_obj[1] ;
28577
28578 if (!args) SWIG_fail;
28579 swig_obj[0] = args;
28580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28581 if (!SWIG_IsOK(res1)) {
28582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28583 }
28584 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 (arg1)->_BootstrapApp();
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 resultobj = SWIG_Py_Void();
28592 return resultobj;
28593 fail:
28594 return NULL;
28595 }
28596
28597
28598 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28599 PyObject *resultobj = 0;
28600 int result;
28601
28602 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (int)wxPyApp::GetComCtl32Version();
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 resultobj = SWIG_From_int(static_cast< int >(result));
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 bool result;
28619
28620 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28621 {
28622 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 result = (bool)wxPyApp_DisplayAvailable();
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 {
28628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28629 }
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28637 PyObject *obj;
28638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28640 return SWIG_Py_Void();
28641 }
28642
28643 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28644 return SWIG_Python_InitShadowInstance(args);
28645 }
28646
28647 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 PyObject *resultobj = 0;
28649
28650 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 wxExit();
28654 wxPyEndAllowThreads(__tstate);
28655 if (PyErr_Occurred()) SWIG_fail;
28656 }
28657 resultobj = SWIG_Py_Void();
28658 return resultobj;
28659 fail:
28660 return NULL;
28661 }
28662
28663
28664 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28665 PyObject *resultobj = 0;
28666 bool result;
28667
28668 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 result = (bool)wxYield();
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 {
28676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28677 }
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28685 PyObject *resultobj = 0;
28686 bool result;
28687
28688 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 result = (bool)wxYieldIfNeeded();
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 {
28696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28697 }
28698 return resultobj;
28699 fail:
28700 return NULL;
28701 }
28702
28703
28704 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28705 PyObject *resultobj = 0;
28706 wxWindow *arg1 = (wxWindow *) NULL ;
28707 bool arg2 = (bool) false ;
28708 bool result;
28709 void *argp1 = 0 ;
28710 int res1 = 0 ;
28711 bool val2 ;
28712 int ecode2 = 0 ;
28713 PyObject * obj0 = 0 ;
28714 PyObject * obj1 = 0 ;
28715 char * kwnames[] = {
28716 (char *) "win",(char *) "onlyIfNeeded", NULL
28717 };
28718
28719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28720 if (obj0) {
28721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28722 if (!SWIG_IsOK(res1)) {
28723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28724 }
28725 arg1 = reinterpret_cast< wxWindow * >(argp1);
28726 }
28727 if (obj1) {
28728 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28729 if (!SWIG_IsOK(ecode2)) {
28730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28731 }
28732 arg2 = static_cast< bool >(val2);
28733 }
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = (bool)wxSafeYield(arg1,arg2);
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 {
28741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28742 }
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28750 PyObject *resultobj = 0;
28751
28752 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28753 {
28754 PyThreadState* __tstate = wxPyBeginAllowThreads();
28755 wxWakeUpIdle();
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 resultobj = SWIG_Py_Void();
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj = 0;
28768 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28769 wxEvent *arg2 = 0 ;
28770 void *argp1 = 0 ;
28771 int res1 = 0 ;
28772 void *argp2 = 0 ;
28773 int res2 = 0 ;
28774 PyObject * obj0 = 0 ;
28775 PyObject * obj1 = 0 ;
28776 char * kwnames[] = {
28777 (char *) "dest",(char *) "event", NULL
28778 };
28779
28780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28782 if (!SWIG_IsOK(res1)) {
28783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28784 }
28785 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28786 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28787 if (!SWIG_IsOK(res2)) {
28788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28789 }
28790 if (!argp2) {
28791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28792 }
28793 arg2 = reinterpret_cast< wxEvent * >(argp2);
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 wxPostEvent(arg1,*arg2);
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 resultobj = SWIG_Py_Void();
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28808 PyObject *resultobj = 0;
28809
28810 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 wxApp_CleanUp();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_Py_Void();
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxPyApp *result = 0 ;
28827
28828 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = (wxPyApp *)wxPyGetApp();
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 {
28836 resultobj = wxPyMake_wxObject(result, 0);
28837 }
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28845 PyObject *resultobj = 0;
28846 char *arg1 = (char *) 0 ;
28847 int res1 ;
28848 char *buf1 = 0 ;
28849 int alloc1 = 0 ;
28850 PyObject * obj0 = 0 ;
28851 char * kwnames[] = {
28852 (char *) "encoding", NULL
28853 };
28854
28855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28856 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28857 if (!SWIG_IsOK(res1)) {
28858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28859 }
28860 arg1 = buf1;
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 wxSetDefaultPyEncoding((char const *)arg1);
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 resultobj = SWIG_Py_Void();
28868 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28869 return resultobj;
28870 fail:
28871 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28872 return NULL;
28873 }
28874
28875
28876 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28877 PyObject *resultobj = 0;
28878 char *result = 0 ;
28879
28880 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28881 {
28882 PyThreadState* __tstate = wxPyBeginAllowThreads();
28883 result = (char *)wxGetDefaultPyEncoding();
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 resultobj = SWIG_FromCharPtr(result);
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28895 PyObject *resultobj = 0;
28896 wxEventLoop *result = 0 ;
28897
28898 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 result = (wxEventLoop *)new wxEventLoop();
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28906 return resultobj;
28907 fail:
28908 return NULL;
28909 }
28910
28911
28912 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28913 PyObject *resultobj = 0;
28914 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28915 void *argp1 = 0 ;
28916 int res1 = 0 ;
28917 PyObject *swig_obj[1] ;
28918
28919 if (!args) SWIG_fail;
28920 swig_obj[0] = args;
28921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28922 if (!SWIG_IsOK(res1)) {
28923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28924 }
28925 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 delete arg1;
28929
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 resultobj = SWIG_Py_Void();
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28941 PyObject *resultobj = 0;
28942 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28943 int result;
28944 void *argp1 = 0 ;
28945 int res1 = 0 ;
28946 PyObject *swig_obj[1] ;
28947
28948 if (!args) SWIG_fail;
28949 swig_obj[0] = args;
28950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28951 if (!SWIG_IsOK(res1)) {
28952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28953 }
28954 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28955 {
28956 PyThreadState* __tstate = wxPyBeginAllowThreads();
28957 result = (int)(arg1)->Run();
28958 wxPyEndAllowThreads(__tstate);
28959 if (PyErr_Occurred()) SWIG_fail;
28960 }
28961 resultobj = SWIG_From_int(static_cast< int >(result));
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28969 PyObject *resultobj = 0;
28970 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28971 int arg2 = (int) 0 ;
28972 void *argp1 = 0 ;
28973 int res1 = 0 ;
28974 int val2 ;
28975 int ecode2 = 0 ;
28976 PyObject * obj0 = 0 ;
28977 PyObject * obj1 = 0 ;
28978 char * kwnames[] = {
28979 (char *) "self",(char *) "rc", NULL
28980 };
28981
28982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28984 if (!SWIG_IsOK(res1)) {
28985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28986 }
28987 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28988 if (obj1) {
28989 ecode2 = SWIG_AsVal_int(obj1, &val2);
28990 if (!SWIG_IsOK(ecode2)) {
28991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28992 }
28993 arg2 = static_cast< int >(val2);
28994 }
28995 {
28996 PyThreadState* __tstate = wxPyBeginAllowThreads();
28997 (arg1)->Exit(arg2);
28998 wxPyEndAllowThreads(__tstate);
28999 if (PyErr_Occurred()) SWIG_fail;
29000 }
29001 resultobj = SWIG_Py_Void();
29002 return resultobj;
29003 fail:
29004 return NULL;
29005 }
29006
29007
29008 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29009 PyObject *resultobj = 0;
29010 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29011 bool result;
29012 void *argp1 = 0 ;
29013 int res1 = 0 ;
29014 PyObject *swig_obj[1] ;
29015
29016 if (!args) SWIG_fail;
29017 swig_obj[0] = args;
29018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29019 if (!SWIG_IsOK(res1)) {
29020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29021 }
29022 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 result = (bool)((wxEventLoop const *)arg1)->Pending();
29026 wxPyEndAllowThreads(__tstate);
29027 if (PyErr_Occurred()) SWIG_fail;
29028 }
29029 {
29030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29031 }
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29039 PyObject *resultobj = 0;
29040 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29041 bool result;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject *swig_obj[1] ;
29045
29046 if (!args) SWIG_fail;
29047 swig_obj[0] = args;
29048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29051 }
29052 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = (bool)(arg1)->Dispatch();
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 {
29060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29061 }
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29069 PyObject *resultobj = 0;
29070 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29071 bool result;
29072 void *argp1 = 0 ;
29073 int res1 = 0 ;
29074 PyObject *swig_obj[1] ;
29075
29076 if (!args) SWIG_fail;
29077 swig_obj[0] = args;
29078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29079 if (!SWIG_IsOK(res1)) {
29080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29081 }
29082 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 {
29090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29091 }
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29099 PyObject *resultobj = 0;
29100 wxEventLoop *result = 0 ;
29101
29102 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29103 {
29104 PyThreadState* __tstate = wxPyBeginAllowThreads();
29105 result = (wxEventLoop *)wxEventLoop::GetActive();
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj = 0;
29118 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29119 void *argp1 = 0 ;
29120 int res1 = 0 ;
29121 PyObject * obj0 = 0 ;
29122 char * kwnames[] = {
29123 (char *) "loop", NULL
29124 };
29125
29126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29128 if (!SWIG_IsOK(res1)) {
29129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29130 }
29131 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29132 {
29133 PyThreadState* __tstate = wxPyBeginAllowThreads();
29134 wxEventLoop::SetActive(arg1);
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 resultobj = SWIG_Py_Void();
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29146 PyObject *obj;
29147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29148 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29149 return SWIG_Py_Void();
29150 }
29151
29152 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29153 return SWIG_Python_InitShadowInstance(args);
29154 }
29155
29156 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29157 PyObject *resultobj = 0;
29158 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29159 wxEventLoopActivator *result = 0 ;
29160 void *argp1 = 0 ;
29161 int res1 = 0 ;
29162 PyObject * obj0 = 0 ;
29163 char * kwnames[] = {
29164 (char *) "evtLoop", NULL
29165 };
29166
29167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29169 if (!SWIG_IsOK(res1)) {
29170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29171 }
29172 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29173 {
29174 PyThreadState* __tstate = wxPyBeginAllowThreads();
29175 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29176 wxPyEndAllowThreads(__tstate);
29177 if (PyErr_Occurred()) SWIG_fail;
29178 }
29179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29187 PyObject *resultobj = 0;
29188 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29189 void *argp1 = 0 ;
29190 int res1 = 0 ;
29191 PyObject *swig_obj[1] ;
29192
29193 if (!args) SWIG_fail;
29194 swig_obj[0] = args;
29195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29196 if (!SWIG_IsOK(res1)) {
29197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29198 }
29199 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 delete arg1;
29203
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 resultobj = SWIG_Py_Void();
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29215 PyObject *obj;
29216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29217 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29218 return SWIG_Py_Void();
29219 }
29220
29221 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 return SWIG_Python_InitShadowInstance(args);
29223 }
29224
29225 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29226 PyObject *resultobj = 0;
29227 int arg1 = (int) 0 ;
29228 int arg2 = (int) 0 ;
29229 int arg3 = (int) 0 ;
29230 wxAcceleratorEntry *result = 0 ;
29231 int val1 ;
29232 int ecode1 = 0 ;
29233 int val2 ;
29234 int ecode2 = 0 ;
29235 int val3 ;
29236 int ecode3 = 0 ;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 PyObject * obj2 = 0 ;
29240 char * kwnames[] = {
29241 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29242 };
29243
29244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29245 if (obj0) {
29246 ecode1 = SWIG_AsVal_int(obj0, &val1);
29247 if (!SWIG_IsOK(ecode1)) {
29248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29249 }
29250 arg1 = static_cast< int >(val1);
29251 }
29252 if (obj1) {
29253 ecode2 = SWIG_AsVal_int(obj1, &val2);
29254 if (!SWIG_IsOK(ecode2)) {
29255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29256 }
29257 arg2 = static_cast< int >(val2);
29258 }
29259 if (obj2) {
29260 ecode3 = SWIG_AsVal_int(obj2, &val3);
29261 if (!SWIG_IsOK(ecode3)) {
29262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29263 }
29264 arg3 = static_cast< int >(val3);
29265 }
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29282 void *argp1 = 0 ;
29283 int res1 = 0 ;
29284 PyObject *swig_obj[1] ;
29285
29286 if (!args) SWIG_fail;
29287 swig_obj[0] = args;
29288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29289 if (!SWIG_IsOK(res1)) {
29290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29291 }
29292 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29293 {
29294 PyThreadState* __tstate = wxPyBeginAllowThreads();
29295 delete arg1;
29296
29297 wxPyEndAllowThreads(__tstate);
29298 if (PyErr_Occurred()) SWIG_fail;
29299 }
29300 resultobj = SWIG_Py_Void();
29301 return resultobj;
29302 fail:
29303 return NULL;
29304 }
29305
29306
29307 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29308 PyObject *resultobj = 0;
29309 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29310 int arg2 ;
29311 int arg3 ;
29312 int arg4 ;
29313 void *argp1 = 0 ;
29314 int res1 = 0 ;
29315 int val2 ;
29316 int ecode2 = 0 ;
29317 int val3 ;
29318 int ecode3 = 0 ;
29319 int val4 ;
29320 int ecode4 = 0 ;
29321 PyObject * obj0 = 0 ;
29322 PyObject * obj1 = 0 ;
29323 PyObject * obj2 = 0 ;
29324 PyObject * obj3 = 0 ;
29325 char * kwnames[] = {
29326 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29327 };
29328
29329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29331 if (!SWIG_IsOK(res1)) {
29332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29333 }
29334 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29335 ecode2 = SWIG_AsVal_int(obj1, &val2);
29336 if (!SWIG_IsOK(ecode2)) {
29337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29338 }
29339 arg2 = static_cast< int >(val2);
29340 ecode3 = SWIG_AsVal_int(obj2, &val3);
29341 if (!SWIG_IsOK(ecode3)) {
29342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29343 }
29344 arg3 = static_cast< int >(val3);
29345 ecode4 = SWIG_AsVal_int(obj3, &val4);
29346 if (!SWIG_IsOK(ecode4)) {
29347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29348 }
29349 arg4 = static_cast< int >(val4);
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 (arg1)->Set(arg2,arg3,arg4);
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_Py_Void();
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 wxString *arg1 = 0 ;
29366 wxAcceleratorEntry *result = 0 ;
29367 bool temp1 = false ;
29368 PyObject * obj0 = 0 ;
29369 char * kwnames[] = {
29370 (char *) "str", NULL
29371 };
29372
29373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29374 {
29375 arg1 = wxString_in_helper(obj0);
29376 if (arg1 == NULL) SWIG_fail;
29377 temp1 = true;
29378 }
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29386 {
29387 if (temp1)
29388 delete arg1;
29389 }
29390 return resultobj;
29391 fail:
29392 {
29393 if (temp1)
29394 delete arg1;
29395 }
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 PyObject *resultobj = 0;
29402 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29403 int result;
29404 void *argp1 = 0 ;
29405 int res1 = 0 ;
29406 PyObject *swig_obj[1] ;
29407
29408 if (!args) SWIG_fail;
29409 swig_obj[0] = args;
29410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29411 if (!SWIG_IsOK(res1)) {
29412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29413 }
29414 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (int)(arg1)->GetFlags();
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 resultobj = SWIG_From_int(static_cast< int >(result));
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29429 PyObject *resultobj = 0;
29430 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29431 int result;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 PyObject *swig_obj[1] ;
29435
29436 if (!args) SWIG_fail;
29437 swig_obj[0] = args;
29438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29439 if (!SWIG_IsOK(res1)) {
29440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29441 }
29442 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29443 {
29444 PyThreadState* __tstate = wxPyBeginAllowThreads();
29445 result = (int)(arg1)->GetKeyCode();
29446 wxPyEndAllowThreads(__tstate);
29447 if (PyErr_Occurred()) SWIG_fail;
29448 }
29449 resultobj = SWIG_From_int(static_cast< int >(result));
29450 return resultobj;
29451 fail:
29452 return NULL;
29453 }
29454
29455
29456 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29457 PyObject *resultobj = 0;
29458 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29459 int result;
29460 void *argp1 = 0 ;
29461 int res1 = 0 ;
29462 PyObject *swig_obj[1] ;
29463
29464 if (!args) SWIG_fail;
29465 swig_obj[0] = args;
29466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29467 if (!SWIG_IsOK(res1)) {
29468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29469 }
29470 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 result = (int)(arg1)->GetCommand();
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 resultobj = SWIG_From_int(static_cast< int >(result));
29478 return resultobj;
29479 fail:
29480 return NULL;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29485 PyObject *resultobj = 0;
29486 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29487 bool result;
29488 void *argp1 = 0 ;
29489 int res1 = 0 ;
29490 PyObject *swig_obj[1] ;
29491
29492 if (!args) SWIG_fail;
29493 swig_obj[0] = args;
29494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29495 if (!SWIG_IsOK(res1)) {
29496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29497 }
29498 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29499 {
29500 PyThreadState* __tstate = wxPyBeginAllowThreads();
29501 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29502 wxPyEndAllowThreads(__tstate);
29503 if (PyErr_Occurred()) SWIG_fail;
29504 }
29505 {
29506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29507 }
29508 return resultobj;
29509 fail:
29510 return NULL;
29511 }
29512
29513
29514 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29515 PyObject *resultobj = 0;
29516 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29517 wxString result;
29518 void *argp1 = 0 ;
29519 int res1 = 0 ;
29520 PyObject *swig_obj[1] ;
29521
29522 if (!args) SWIG_fail;
29523 swig_obj[0] = args;
29524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29525 if (!SWIG_IsOK(res1)) {
29526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29527 }
29528 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29529 {
29530 PyThreadState* __tstate = wxPyBeginAllowThreads();
29531 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29532 wxPyEndAllowThreads(__tstate);
29533 if (PyErr_Occurred()) SWIG_fail;
29534 }
29535 {
29536 #if wxUSE_UNICODE
29537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29538 #else
29539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29540 #endif
29541 }
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29549 PyObject *resultobj = 0;
29550 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29551 wxString *arg2 = 0 ;
29552 bool result;
29553 void *argp1 = 0 ;
29554 int res1 = 0 ;
29555 bool temp2 = false ;
29556 PyObject * obj0 = 0 ;
29557 PyObject * obj1 = 0 ;
29558 char * kwnames[] = {
29559 (char *) "self",(char *) "str", NULL
29560 };
29561
29562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29564 if (!SWIG_IsOK(res1)) {
29565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29566 }
29567 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29568 {
29569 arg2 = wxString_in_helper(obj1);
29570 if (arg2 == NULL) SWIG_fail;
29571 temp2 = true;
29572 }
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 {
29580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29581 }
29582 {
29583 if (temp2)
29584 delete arg2;
29585 }
29586 return resultobj;
29587 fail:
29588 {
29589 if (temp2)
29590 delete arg2;
29591 }
29592 return NULL;
29593 }
29594
29595
29596 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29597 PyObject *obj;
29598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29599 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29600 return SWIG_Py_Void();
29601 }
29602
29603 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29604 return SWIG_Python_InitShadowInstance(args);
29605 }
29606
29607 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29608 PyObject *resultobj = 0;
29609 int arg1 ;
29610 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29611 wxAcceleratorTable *result = 0 ;
29612 PyObject * obj0 = 0 ;
29613 char * kwnames[] = {
29614 (char *) "n", NULL
29615 };
29616
29617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29618 {
29619 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29620 if (arg2) arg1 = PyList_Size(obj0);
29621 else arg1 = 0;
29622 }
29623 {
29624 PyThreadState* __tstate = wxPyBeginAllowThreads();
29625 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29626 wxPyEndAllowThreads(__tstate);
29627 if (PyErr_Occurred()) SWIG_fail;
29628 }
29629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29637 PyObject *resultobj = 0;
29638 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 PyObject *swig_obj[1] ;
29642
29643 if (!args) SWIG_fail;
29644 swig_obj[0] = args;
29645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29648 }
29649 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 delete arg1;
29653
29654 wxPyEndAllowThreads(__tstate);
29655 if (PyErr_Occurred()) SWIG_fail;
29656 }
29657 resultobj = SWIG_Py_Void();
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29665 PyObject *resultobj = 0;
29666 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29667 bool result;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 PyObject *swig_obj[1] ;
29671
29672 if (!args) SWIG_fail;
29673 swig_obj[0] = args;
29674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29677 }
29678 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29687 }
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29695 PyObject *obj;
29696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29697 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29698 return SWIG_Py_Void();
29699 }
29700
29701 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29702 return SWIG_Python_InitShadowInstance(args);
29703 }
29704
29705 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29706 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29707 return 1;
29708 }
29709
29710
29711 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29712 PyObject *pyobj = 0;
29713
29714 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29715 return pyobj;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29720 PyObject *resultobj = 0;
29721 wxString *arg1 = 0 ;
29722 wxAcceleratorEntry *result = 0 ;
29723 bool temp1 = false ;
29724 PyObject * obj0 = 0 ;
29725 char * kwnames[] = {
29726 (char *) "label", NULL
29727 };
29728
29729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29730 {
29731 arg1 = wxString_in_helper(obj0);
29732 if (arg1 == NULL) SWIG_fail;
29733 temp1 = true;
29734 }
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29742 {
29743 if (temp1)
29744 delete arg1;
29745 }
29746 return resultobj;
29747 fail:
29748 {
29749 if (temp1)
29750 delete arg1;
29751 }
29752 return NULL;
29753 }
29754
29755
29756 SWIGINTERN int PanelNameStr_set(PyObject *) {
29757 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29758 return 1;
29759 }
29760
29761
29762 SWIGINTERN PyObject *PanelNameStr_get(void) {
29763 PyObject *pyobj = 0;
29764
29765 {
29766 #if wxUSE_UNICODE
29767 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29768 #else
29769 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29770 #endif
29771 }
29772 return pyobj;
29773 }
29774
29775
29776 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29777 PyObject *resultobj = 0;
29778 wxVisualAttributes *result = 0 ;
29779
29780 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29781 {
29782 PyThreadState* __tstate = wxPyBeginAllowThreads();
29783 result = (wxVisualAttributes *)new_wxVisualAttributes();
29784 wxPyEndAllowThreads(__tstate);
29785 if (PyErr_Occurred()) SWIG_fail;
29786 }
29787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29795 PyObject *resultobj = 0;
29796 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 PyObject *swig_obj[1] ;
29800
29801 if (!args) SWIG_fail;
29802 swig_obj[0] = args;
29803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29806 }
29807 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 delete_wxVisualAttributes(arg1);
29811
29812 wxPyEndAllowThreads(__tstate);
29813 if (PyErr_Occurred()) SWIG_fail;
29814 }
29815 resultobj = SWIG_Py_Void();
29816 return resultobj;
29817 fail:
29818 return NULL;
29819 }
29820
29821
29822 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29823 PyObject *resultobj = 0;
29824 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29825 wxFont *arg2 = (wxFont *) 0 ;
29826 void *argp1 = 0 ;
29827 int res1 = 0 ;
29828 void *argp2 = 0 ;
29829 int res2 = 0 ;
29830 PyObject *swig_obj[2] ;
29831
29832 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29834 if (!SWIG_IsOK(res1)) {
29835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29836 }
29837 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29838 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29839 if (!SWIG_IsOK(res2)) {
29840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29841 }
29842 arg2 = reinterpret_cast< wxFont * >(argp2);
29843 if (arg1) (arg1)->font = *arg2;
29844
29845 resultobj = SWIG_Py_Void();
29846 return resultobj;
29847 fail:
29848 return NULL;
29849 }
29850
29851
29852 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29853 PyObject *resultobj = 0;
29854 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29855 wxFont *result = 0 ;
29856 void *argp1 = 0 ;
29857 int res1 = 0 ;
29858 PyObject *swig_obj[1] ;
29859
29860 if (!args) SWIG_fail;
29861 swig_obj[0] = args;
29862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29863 if (!SWIG_IsOK(res1)) {
29864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29865 }
29866 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29867 result = (wxFont *)& ((arg1)->font);
29868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29876 PyObject *resultobj = 0;
29877 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29878 wxColour *arg2 = (wxColour *) 0 ;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 void *argp2 = 0 ;
29882 int res2 = 0 ;
29883 PyObject *swig_obj[2] ;
29884
29885 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29887 if (!SWIG_IsOK(res1)) {
29888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29889 }
29890 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29891 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29892 if (!SWIG_IsOK(res2)) {
29893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29894 }
29895 arg2 = reinterpret_cast< wxColour * >(argp2);
29896 if (arg1) (arg1)->colFg = *arg2;
29897
29898 resultobj = SWIG_Py_Void();
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29906 PyObject *resultobj = 0;
29907 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29908 wxColour *result = 0 ;
29909 void *argp1 = 0 ;
29910 int res1 = 0 ;
29911 PyObject *swig_obj[1] ;
29912
29913 if (!args) SWIG_fail;
29914 swig_obj[0] = args;
29915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29916 if (!SWIG_IsOK(res1)) {
29917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29918 }
29919 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29920 result = (wxColour *)& ((arg1)->colFg);
29921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29922 return resultobj;
29923 fail:
29924 return NULL;
29925 }
29926
29927
29928 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29929 PyObject *resultobj = 0;
29930 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29931 wxColour *arg2 = (wxColour *) 0 ;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 void *argp2 = 0 ;
29935 int res2 = 0 ;
29936 PyObject *swig_obj[2] ;
29937
29938 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29940 if (!SWIG_IsOK(res1)) {
29941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29942 }
29943 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29944 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29945 if (!SWIG_IsOK(res2)) {
29946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29947 }
29948 arg2 = reinterpret_cast< wxColour * >(argp2);
29949 if (arg1) (arg1)->colBg = *arg2;
29950
29951 resultobj = SWIG_Py_Void();
29952 return resultobj;
29953 fail:
29954 return NULL;
29955 }
29956
29957
29958 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29959 PyObject *resultobj = 0;
29960 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29961 wxColour *result = 0 ;
29962 void *argp1 = 0 ;
29963 int res1 = 0 ;
29964 PyObject *swig_obj[1] ;
29965
29966 if (!args) SWIG_fail;
29967 swig_obj[0] = args;
29968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29969 if (!SWIG_IsOK(res1)) {
29970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29971 }
29972 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29973 result = (wxColour *)& ((arg1)->colBg);
29974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29982 PyObject *obj;
29983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29984 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29985 return SWIG_Py_Void();
29986 }
29987
29988 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29989 return SWIG_Python_InitShadowInstance(args);
29990 }
29991
29992 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29993 PyObject *resultobj = 0;
29994 wxWindow *arg1 = (wxWindow *) 0 ;
29995 int arg2 = (int) (int)-1 ;
29996 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29997 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29998 wxSize const &arg4_defvalue = wxDefaultSize ;
29999 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30000 long arg5 = (long) 0 ;
30001 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30002 wxString *arg6 = (wxString *) &arg6_defvalue ;
30003 wxWindow *result = 0 ;
30004 void *argp1 = 0 ;
30005 int res1 = 0 ;
30006 int val2 ;
30007 int ecode2 = 0 ;
30008 wxPoint temp3 ;
30009 wxSize temp4 ;
30010 long val5 ;
30011 int ecode5 = 0 ;
30012 bool temp6 = false ;
30013 PyObject * obj0 = 0 ;
30014 PyObject * obj1 = 0 ;
30015 PyObject * obj2 = 0 ;
30016 PyObject * obj3 = 0 ;
30017 PyObject * obj4 = 0 ;
30018 PyObject * obj5 = 0 ;
30019 char * kwnames[] = {
30020 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30021 };
30022
30023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30025 if (!SWIG_IsOK(res1)) {
30026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30027 }
30028 arg1 = reinterpret_cast< wxWindow * >(argp1);
30029 if (obj1) {
30030 ecode2 = SWIG_AsVal_int(obj1, &val2);
30031 if (!SWIG_IsOK(ecode2)) {
30032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30033 }
30034 arg2 = static_cast< int >(val2);
30035 }
30036 if (obj2) {
30037 {
30038 arg3 = &temp3;
30039 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30040 }
30041 }
30042 if (obj3) {
30043 {
30044 arg4 = &temp4;
30045 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30046 }
30047 }
30048 if (obj4) {
30049 ecode5 = SWIG_AsVal_long(obj4, &val5);
30050 if (!SWIG_IsOK(ecode5)) {
30051 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30052 }
30053 arg5 = static_cast< long >(val5);
30054 }
30055 if (obj5) {
30056 {
30057 arg6 = wxString_in_helper(obj5);
30058 if (arg6 == NULL) SWIG_fail;
30059 temp6 = true;
30060 }
30061 }
30062 {
30063 if (!wxPyCheckForApp()) SWIG_fail;
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30070 {
30071 if (temp6)
30072 delete arg6;
30073 }
30074 return resultobj;
30075 fail:
30076 {
30077 if (temp6)
30078 delete arg6;
30079 }
30080 return NULL;
30081 }
30082
30083
30084 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30085 PyObject *resultobj = 0;
30086 wxWindow *result = 0 ;
30087
30088 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30089 {
30090 if (!wxPyCheckForApp()) SWIG_fail;
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (wxWindow *)new wxWindow();
30093 wxPyEndAllowThreads(__tstate);
30094 if (PyErr_Occurred()) SWIG_fail;
30095 }
30096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30104 PyObject *resultobj = 0;
30105 wxWindow *arg1 = (wxWindow *) 0 ;
30106 wxWindow *arg2 = (wxWindow *) 0 ;
30107 int arg3 = (int) (int)-1 ;
30108 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30109 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30110 wxSize const &arg5_defvalue = wxDefaultSize ;
30111 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30112 long arg6 = (long) 0 ;
30113 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30114 wxString *arg7 = (wxString *) &arg7_defvalue ;
30115 bool result;
30116 void *argp1 = 0 ;
30117 int res1 = 0 ;
30118 void *argp2 = 0 ;
30119 int res2 = 0 ;
30120 int val3 ;
30121 int ecode3 = 0 ;
30122 wxPoint temp4 ;
30123 wxSize temp5 ;
30124 long val6 ;
30125 int ecode6 = 0 ;
30126 bool temp7 = false ;
30127 PyObject * obj0 = 0 ;
30128 PyObject * obj1 = 0 ;
30129 PyObject * obj2 = 0 ;
30130 PyObject * obj3 = 0 ;
30131 PyObject * obj4 = 0 ;
30132 PyObject * obj5 = 0 ;
30133 PyObject * obj6 = 0 ;
30134 char * kwnames[] = {
30135 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30136 };
30137
30138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30140 if (!SWIG_IsOK(res1)) {
30141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30142 }
30143 arg1 = reinterpret_cast< wxWindow * >(argp1);
30144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30145 if (!SWIG_IsOK(res2)) {
30146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30147 }
30148 arg2 = reinterpret_cast< wxWindow * >(argp2);
30149 if (obj2) {
30150 ecode3 = SWIG_AsVal_int(obj2, &val3);
30151 if (!SWIG_IsOK(ecode3)) {
30152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30153 }
30154 arg3 = static_cast< int >(val3);
30155 }
30156 if (obj3) {
30157 {
30158 arg4 = &temp4;
30159 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30160 }
30161 }
30162 if (obj4) {
30163 {
30164 arg5 = &temp5;
30165 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30166 }
30167 }
30168 if (obj5) {
30169 ecode6 = SWIG_AsVal_long(obj5, &val6);
30170 if (!SWIG_IsOK(ecode6)) {
30171 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30172 }
30173 arg6 = static_cast< long >(val6);
30174 }
30175 if (obj6) {
30176 {
30177 arg7 = wxString_in_helper(obj6);
30178 if (arg7 == NULL) SWIG_fail;
30179 temp7 = true;
30180 }
30181 }
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 {
30189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30190 }
30191 {
30192 if (temp7)
30193 delete arg7;
30194 }
30195 return resultobj;
30196 fail:
30197 {
30198 if (temp7)
30199 delete arg7;
30200 }
30201 return NULL;
30202 }
30203
30204
30205 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj = 0;
30207 wxWindow *arg1 = (wxWindow *) 0 ;
30208 bool arg2 = (bool) false ;
30209 bool result;
30210 void *argp1 = 0 ;
30211 int res1 = 0 ;
30212 bool val2 ;
30213 int ecode2 = 0 ;
30214 PyObject * obj0 = 0 ;
30215 PyObject * obj1 = 0 ;
30216 char * kwnames[] = {
30217 (char *) "self",(char *) "force", NULL
30218 };
30219
30220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30222 if (!SWIG_IsOK(res1)) {
30223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30224 }
30225 arg1 = reinterpret_cast< wxWindow * >(argp1);
30226 if (obj1) {
30227 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30228 if (!SWIG_IsOK(ecode2)) {
30229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30230 }
30231 arg2 = static_cast< bool >(val2);
30232 }
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = (bool)(arg1)->Close(arg2);
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 {
30240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30241 }
30242 return resultobj;
30243 fail:
30244 return NULL;
30245 }
30246
30247
30248 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30249 PyObject *resultobj = 0;
30250 wxWindow *arg1 = (wxWindow *) 0 ;
30251 bool result;
30252 void *argp1 = 0 ;
30253 int res1 = 0 ;
30254 PyObject *swig_obj[1] ;
30255
30256 if (!args) SWIG_fail;
30257 swig_obj[0] = args;
30258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30259 if (!SWIG_IsOK(res1)) {
30260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30261 }
30262 arg1 = reinterpret_cast< wxWindow * >(argp1);
30263 {
30264 PyThreadState* __tstate = wxPyBeginAllowThreads();
30265 result = (bool)(arg1)->Destroy();
30266 wxPyEndAllowThreads(__tstate);
30267 if (PyErr_Occurred()) SWIG_fail;
30268 }
30269 {
30270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30271 }
30272 return resultobj;
30273 fail:
30274 return NULL;
30275 }
30276
30277
30278 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30279 PyObject *resultobj = 0;
30280 wxWindow *arg1 = (wxWindow *) 0 ;
30281 bool result;
30282 void *argp1 = 0 ;
30283 int res1 = 0 ;
30284 PyObject *swig_obj[1] ;
30285
30286 if (!args) SWIG_fail;
30287 swig_obj[0] = args;
30288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30289 if (!SWIG_IsOK(res1)) {
30290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30291 }
30292 arg1 = reinterpret_cast< wxWindow * >(argp1);
30293 {
30294 PyThreadState* __tstate = wxPyBeginAllowThreads();
30295 result = (bool)(arg1)->DestroyChildren();
30296 wxPyEndAllowThreads(__tstate);
30297 if (PyErr_Occurred()) SWIG_fail;
30298 }
30299 {
30300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30301 }
30302 return resultobj;
30303 fail:
30304 return NULL;
30305 }
30306
30307
30308 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30309 PyObject *resultobj = 0;
30310 wxWindow *arg1 = (wxWindow *) 0 ;
30311 bool result;
30312 void *argp1 = 0 ;
30313 int res1 = 0 ;
30314 PyObject *swig_obj[1] ;
30315
30316 if (!args) SWIG_fail;
30317 swig_obj[0] = args;
30318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30319 if (!SWIG_IsOK(res1)) {
30320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30321 }
30322 arg1 = reinterpret_cast< wxWindow * >(argp1);
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 {
30330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj = 0;
30340 wxWindow *arg1 = (wxWindow *) 0 ;
30341 wxString *arg2 = 0 ;
30342 void *argp1 = 0 ;
30343 int res1 = 0 ;
30344 bool temp2 = false ;
30345 PyObject * obj0 = 0 ;
30346 PyObject * obj1 = 0 ;
30347 char * kwnames[] = {
30348 (char *) "self",(char *) "label", NULL
30349 };
30350
30351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30353 if (!SWIG_IsOK(res1)) {
30354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30355 }
30356 arg1 = reinterpret_cast< wxWindow * >(argp1);
30357 {
30358 arg2 = wxString_in_helper(obj1);
30359 if (arg2 == NULL) SWIG_fail;
30360 temp2 = true;
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 (arg1)->SetLabel((wxString const &)*arg2);
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 resultobj = SWIG_Py_Void();
30369 {
30370 if (temp2)
30371 delete arg2;
30372 }
30373 return resultobj;
30374 fail:
30375 {
30376 if (temp2)
30377 delete arg2;
30378 }
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30384 PyObject *resultobj = 0;
30385 wxWindow *arg1 = (wxWindow *) 0 ;
30386 wxString result;
30387 void *argp1 = 0 ;
30388 int res1 = 0 ;
30389 PyObject *swig_obj[1] ;
30390
30391 if (!args) SWIG_fail;
30392 swig_obj[0] = args;
30393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30394 if (!SWIG_IsOK(res1)) {
30395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30396 }
30397 arg1 = reinterpret_cast< wxWindow * >(argp1);
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = ((wxWindow const *)arg1)->GetLabel();
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 {
30405 #if wxUSE_UNICODE
30406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30407 #else
30408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30409 #endif
30410 }
30411 return resultobj;
30412 fail:
30413 return NULL;
30414 }
30415
30416
30417 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30418 PyObject *resultobj = 0;
30419 wxWindow *arg1 = (wxWindow *) 0 ;
30420 wxString *arg2 = 0 ;
30421 void *argp1 = 0 ;
30422 int res1 = 0 ;
30423 bool temp2 = false ;
30424 PyObject * obj0 = 0 ;
30425 PyObject * obj1 = 0 ;
30426 char * kwnames[] = {
30427 (char *) "self",(char *) "name", NULL
30428 };
30429
30430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30432 if (!SWIG_IsOK(res1)) {
30433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30434 }
30435 arg1 = reinterpret_cast< wxWindow * >(argp1);
30436 {
30437 arg2 = wxString_in_helper(obj1);
30438 if (arg2 == NULL) SWIG_fail;
30439 temp2 = true;
30440 }
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 (arg1)->SetName((wxString const &)*arg2);
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 resultobj = SWIG_Py_Void();
30448 {
30449 if (temp2)
30450 delete arg2;
30451 }
30452 return resultobj;
30453 fail:
30454 {
30455 if (temp2)
30456 delete arg2;
30457 }
30458 return NULL;
30459 }
30460
30461
30462 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30463 PyObject *resultobj = 0;
30464 wxWindow *arg1 = (wxWindow *) 0 ;
30465 wxString result;
30466 void *argp1 = 0 ;
30467 int res1 = 0 ;
30468 PyObject *swig_obj[1] ;
30469
30470 if (!args) SWIG_fail;
30471 swig_obj[0] = args;
30472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30473 if (!SWIG_IsOK(res1)) {
30474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30475 }
30476 arg1 = reinterpret_cast< wxWindow * >(argp1);
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 result = ((wxWindow const *)arg1)->GetName();
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 {
30484 #if wxUSE_UNICODE
30485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30486 #else
30487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30488 #endif
30489 }
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj = 0;
30498 wxWindow *arg1 = (wxWindow *) 0 ;
30499 wxWindowVariant arg2 ;
30500 void *argp1 = 0 ;
30501 int res1 = 0 ;
30502 int val2 ;
30503 int ecode2 = 0 ;
30504 PyObject * obj0 = 0 ;
30505 PyObject * obj1 = 0 ;
30506 char * kwnames[] = {
30507 (char *) "self",(char *) "variant", NULL
30508 };
30509
30510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30512 if (!SWIG_IsOK(res1)) {
30513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30514 }
30515 arg1 = reinterpret_cast< wxWindow * >(argp1);
30516 ecode2 = SWIG_AsVal_int(obj1, &val2);
30517 if (!SWIG_IsOK(ecode2)) {
30518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30519 }
30520 arg2 = static_cast< wxWindowVariant >(val2);
30521 {
30522 PyThreadState* __tstate = wxPyBeginAllowThreads();
30523 (arg1)->SetWindowVariant(arg2);
30524 wxPyEndAllowThreads(__tstate);
30525 if (PyErr_Occurred()) SWIG_fail;
30526 }
30527 resultobj = SWIG_Py_Void();
30528 return resultobj;
30529 fail:
30530 return NULL;
30531 }
30532
30533
30534 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30535 PyObject *resultobj = 0;
30536 wxWindow *arg1 = (wxWindow *) 0 ;
30537 wxWindowVariant result;
30538 void *argp1 = 0 ;
30539 int res1 = 0 ;
30540 PyObject *swig_obj[1] ;
30541
30542 if (!args) SWIG_fail;
30543 swig_obj[0] = args;
30544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30545 if (!SWIG_IsOK(res1)) {
30546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30547 }
30548 arg1 = reinterpret_cast< wxWindow * >(argp1);
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30552 wxPyEndAllowThreads(__tstate);
30553 if (PyErr_Occurred()) SWIG_fail;
30554 }
30555 resultobj = SWIG_From_int(static_cast< int >(result));
30556 return resultobj;
30557 fail:
30558 return NULL;
30559 }
30560
30561
30562 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30563 PyObject *resultobj = 0;
30564 wxWindow *arg1 = (wxWindow *) 0 ;
30565 int arg2 ;
30566 void *argp1 = 0 ;
30567 int res1 = 0 ;
30568 int val2 ;
30569 int ecode2 = 0 ;
30570 PyObject * obj0 = 0 ;
30571 PyObject * obj1 = 0 ;
30572 char * kwnames[] = {
30573 (char *) "self",(char *) "winid", NULL
30574 };
30575
30576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30578 if (!SWIG_IsOK(res1)) {
30579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30580 }
30581 arg1 = reinterpret_cast< wxWindow * >(argp1);
30582 ecode2 = SWIG_AsVal_int(obj1, &val2);
30583 if (!SWIG_IsOK(ecode2)) {
30584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30585 }
30586 arg2 = static_cast< int >(val2);
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 (arg1)->SetId(arg2);
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 resultobj = SWIG_Py_Void();
30594 return resultobj;
30595 fail:
30596 return NULL;
30597 }
30598
30599
30600 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30601 PyObject *resultobj = 0;
30602 wxWindow *arg1 = (wxWindow *) 0 ;
30603 int result;
30604 void *argp1 = 0 ;
30605 int res1 = 0 ;
30606 PyObject *swig_obj[1] ;
30607
30608 if (!args) SWIG_fail;
30609 swig_obj[0] = args;
30610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30613 }
30614 arg1 = reinterpret_cast< wxWindow * >(argp1);
30615 {
30616 PyThreadState* __tstate = wxPyBeginAllowThreads();
30617 result = (int)((wxWindow const *)arg1)->GetId();
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 resultobj = SWIG_From_int(static_cast< int >(result));
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30629 PyObject *resultobj = 0;
30630 int result;
30631
30632 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30633 {
30634 PyThreadState* __tstate = wxPyBeginAllowThreads();
30635 result = (int)wxWindow::NewControlId();
30636 wxPyEndAllowThreads(__tstate);
30637 if (PyErr_Occurred()) SWIG_fail;
30638 }
30639 resultobj = SWIG_From_int(static_cast< int >(result));
30640 return resultobj;
30641 fail:
30642 return NULL;
30643 }
30644
30645
30646 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30647 PyObject *resultobj = 0;
30648 int arg1 ;
30649 int result;
30650 int val1 ;
30651 int ecode1 = 0 ;
30652 PyObject * obj0 = 0 ;
30653 char * kwnames[] = {
30654 (char *) "winid", NULL
30655 };
30656
30657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30658 ecode1 = SWIG_AsVal_int(obj0, &val1);
30659 if (!SWIG_IsOK(ecode1)) {
30660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30661 }
30662 arg1 = static_cast< int >(val1);
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 result = (int)wxWindow::NextControlId(arg1);
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 resultobj = SWIG_From_int(static_cast< int >(result));
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj = 0;
30678 int arg1 ;
30679 int result;
30680 int val1 ;
30681 int ecode1 = 0 ;
30682 PyObject * obj0 = 0 ;
30683 char * kwnames[] = {
30684 (char *) "winid", NULL
30685 };
30686
30687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30688 ecode1 = SWIG_AsVal_int(obj0, &val1);
30689 if (!SWIG_IsOK(ecode1)) {
30690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30691 }
30692 arg1 = static_cast< int >(val1);
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 result = (int)wxWindow::PrevControlId(arg1);
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_From_int(static_cast< int >(result));
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30707 PyObject *resultobj = 0;
30708 wxWindow *arg1 = (wxWindow *) 0 ;
30709 wxLayoutDirection result;
30710 void *argp1 = 0 ;
30711 int res1 = 0 ;
30712 PyObject *swig_obj[1] ;
30713
30714 if (!args) SWIG_fail;
30715 swig_obj[0] = args;
30716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30719 }
30720 arg1 = reinterpret_cast< wxWindow * >(argp1);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = ((wxWindow const *)arg1)->GetLayoutDirection();
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30735 PyObject *resultobj = 0;
30736 wxWindow *arg1 = (wxWindow *) 0 ;
30737 wxLayoutDirection arg2 ;
30738 void *argp1 = 0 ;
30739 int res1 = 0 ;
30740 void *argp2 ;
30741 int res2 = 0 ;
30742 PyObject * obj0 = 0 ;
30743 PyObject * obj1 = 0 ;
30744 char * kwnames[] = {
30745 (char *) "self",(char *) "dir", NULL
30746 };
30747
30748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30750 if (!SWIG_IsOK(res1)) {
30751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30752 }
30753 arg1 = reinterpret_cast< wxWindow * >(argp1);
30754 {
30755 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxLayoutDirection, 0 | 0);
30756 if (!SWIG_IsOK(res2)) {
30757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30758 }
30759 if (!argp2) {
30760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30761 } else {
30762 wxLayoutDirection * temp = reinterpret_cast< wxLayoutDirection * >(argp2);
30763 arg2 = *temp;
30764 if (SWIG_IsNewObj(res2)) delete temp;
30765 }
30766 }
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 (arg1)->SetLayoutDirection(arg2);
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_Py_Void();
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj = 0;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 int arg2 ;
30784 int arg3 ;
30785 int arg4 ;
30786 int result;
30787 void *argp1 = 0 ;
30788 int res1 = 0 ;
30789 int val2 ;
30790 int ecode2 = 0 ;
30791 int val3 ;
30792 int ecode3 = 0 ;
30793 int val4 ;
30794 int ecode4 = 0 ;
30795 PyObject * obj0 = 0 ;
30796 PyObject * obj1 = 0 ;
30797 PyObject * obj2 = 0 ;
30798 PyObject * obj3 = 0 ;
30799 char * kwnames[] = {
30800 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30801 };
30802
30803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30805 if (!SWIG_IsOK(res1)) {
30806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30807 }
30808 arg1 = reinterpret_cast< wxWindow * >(argp1);
30809 ecode2 = SWIG_AsVal_int(obj1, &val2);
30810 if (!SWIG_IsOK(ecode2)) {
30811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30812 }
30813 arg2 = static_cast< int >(val2);
30814 ecode3 = SWIG_AsVal_int(obj2, &val3);
30815 if (!SWIG_IsOK(ecode3)) {
30816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30817 }
30818 arg3 = static_cast< int >(val3);
30819 ecode4 = SWIG_AsVal_int(obj3, &val4);
30820 if (!SWIG_IsOK(ecode4)) {
30821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30822 }
30823 arg4 = static_cast< int >(val4);
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 resultobj = SWIG_From_int(static_cast< int >(result));
30831 return resultobj;
30832 fail:
30833 return NULL;
30834 }
30835
30836
30837 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30838 PyObject *resultobj = 0;
30839 wxWindow *arg1 = (wxWindow *) 0 ;
30840 wxSize *arg2 = 0 ;
30841 void *argp1 = 0 ;
30842 int res1 = 0 ;
30843 wxSize temp2 ;
30844 PyObject * obj0 = 0 ;
30845 PyObject * obj1 = 0 ;
30846 char * kwnames[] = {
30847 (char *) "self",(char *) "size", NULL
30848 };
30849
30850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30852 if (!SWIG_IsOK(res1)) {
30853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30854 }
30855 arg1 = reinterpret_cast< wxWindow * >(argp1);
30856 {
30857 arg2 = &temp2;
30858 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30859 }
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 (arg1)->SetSize((wxSize const &)*arg2);
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 resultobj = SWIG_Py_Void();
30867 return resultobj;
30868 fail:
30869 return NULL;
30870 }
30871
30872
30873 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30874 PyObject *resultobj = 0;
30875 wxWindow *arg1 = (wxWindow *) 0 ;
30876 int arg2 ;
30877 int arg3 ;
30878 int arg4 ;
30879 int arg5 ;
30880 int arg6 = (int) wxSIZE_AUTO ;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 int val2 ;
30884 int ecode2 = 0 ;
30885 int val3 ;
30886 int ecode3 = 0 ;
30887 int val4 ;
30888 int ecode4 = 0 ;
30889 int val5 ;
30890 int ecode5 = 0 ;
30891 int val6 ;
30892 int ecode6 = 0 ;
30893 PyObject * obj0 = 0 ;
30894 PyObject * obj1 = 0 ;
30895 PyObject * obj2 = 0 ;
30896 PyObject * obj3 = 0 ;
30897 PyObject * obj4 = 0 ;
30898 PyObject * obj5 = 0 ;
30899 char * kwnames[] = {
30900 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30901 };
30902
30903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 ecode2 = SWIG_AsVal_int(obj1, &val2);
30910 if (!SWIG_IsOK(ecode2)) {
30911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30912 }
30913 arg2 = static_cast< int >(val2);
30914 ecode3 = SWIG_AsVal_int(obj2, &val3);
30915 if (!SWIG_IsOK(ecode3)) {
30916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30917 }
30918 arg3 = static_cast< int >(val3);
30919 ecode4 = SWIG_AsVal_int(obj3, &val4);
30920 if (!SWIG_IsOK(ecode4)) {
30921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30922 }
30923 arg4 = static_cast< int >(val4);
30924 ecode5 = SWIG_AsVal_int(obj4, &val5);
30925 if (!SWIG_IsOK(ecode5)) {
30926 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30927 }
30928 arg5 = static_cast< int >(val5);
30929 if (obj5) {
30930 ecode6 = SWIG_AsVal_int(obj5, &val6);
30931 if (!SWIG_IsOK(ecode6)) {
30932 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30933 }
30934 arg6 = static_cast< int >(val6);
30935 }
30936 {
30937 PyThreadState* __tstate = wxPyBeginAllowThreads();
30938 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30939 wxPyEndAllowThreads(__tstate);
30940 if (PyErr_Occurred()) SWIG_fail;
30941 }
30942 resultobj = SWIG_Py_Void();
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj = 0;
30951 wxWindow *arg1 = (wxWindow *) 0 ;
30952 wxRect *arg2 = 0 ;
30953 int arg3 = (int) wxSIZE_AUTO ;
30954 void *argp1 = 0 ;
30955 int res1 = 0 ;
30956 wxRect temp2 ;
30957 int val3 ;
30958 int ecode3 = 0 ;
30959 PyObject * obj0 = 0 ;
30960 PyObject * obj1 = 0 ;
30961 PyObject * obj2 = 0 ;
30962 char * kwnames[] = {
30963 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30964 };
30965
30966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 {
30973 arg2 = &temp2;
30974 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30975 }
30976 if (obj2) {
30977 ecode3 = SWIG_AsVal_int(obj2, &val3);
30978 if (!SWIG_IsOK(ecode3)) {
30979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30980 }
30981 arg3 = static_cast< int >(val3);
30982 }
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 resultobj = SWIG_Py_Void();
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30997 PyObject *resultobj = 0;
30998 wxWindow *arg1 = (wxWindow *) 0 ;
30999 int arg2 ;
31000 int arg3 ;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 int val2 ;
31004 int ecode2 = 0 ;
31005 int val3 ;
31006 int ecode3 = 0 ;
31007 PyObject * obj0 = 0 ;
31008 PyObject * obj1 = 0 ;
31009 PyObject * obj2 = 0 ;
31010 char * kwnames[] = {
31011 (char *) "self",(char *) "width",(char *) "height", NULL
31012 };
31013
31014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31018 }
31019 arg1 = reinterpret_cast< wxWindow * >(argp1);
31020 ecode2 = SWIG_AsVal_int(obj1, &val2);
31021 if (!SWIG_IsOK(ecode2)) {
31022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31023 }
31024 arg2 = static_cast< int >(val2);
31025 ecode3 = SWIG_AsVal_int(obj2, &val3);
31026 if (!SWIG_IsOK(ecode3)) {
31027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31028 }
31029 arg3 = static_cast< int >(val3);
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 (arg1)->SetSize(arg2,arg3);
31033 wxPyEndAllowThreads(__tstate);
31034 if (PyErr_Occurred()) SWIG_fail;
31035 }
31036 resultobj = SWIG_Py_Void();
31037 return resultobj;
31038 fail:
31039 return NULL;
31040 }
31041
31042
31043 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31044 PyObject *resultobj = 0;
31045 wxWindow *arg1 = (wxWindow *) 0 ;
31046 wxPoint *arg2 = 0 ;
31047 int arg3 = (int) wxSIZE_USE_EXISTING ;
31048 void *argp1 = 0 ;
31049 int res1 = 0 ;
31050 wxPoint temp2 ;
31051 int val3 ;
31052 int ecode3 = 0 ;
31053 PyObject * obj0 = 0 ;
31054 PyObject * obj1 = 0 ;
31055 PyObject * obj2 = 0 ;
31056 char * kwnames[] = {
31057 (char *) "self",(char *) "pt",(char *) "flags", NULL
31058 };
31059
31060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31062 if (!SWIG_IsOK(res1)) {
31063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31064 }
31065 arg1 = reinterpret_cast< wxWindow * >(argp1);
31066 {
31067 arg2 = &temp2;
31068 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31069 }
31070 if (obj2) {
31071 ecode3 = SWIG_AsVal_int(obj2, &val3);
31072 if (!SWIG_IsOK(ecode3)) {
31073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31074 }
31075 arg3 = static_cast< int >(val3);
31076 }
31077 {
31078 PyThreadState* __tstate = wxPyBeginAllowThreads();
31079 (arg1)->Move((wxPoint const &)*arg2,arg3);
31080 wxPyEndAllowThreads(__tstate);
31081 if (PyErr_Occurred()) SWIG_fail;
31082 }
31083 resultobj = SWIG_Py_Void();
31084 return resultobj;
31085 fail:
31086 return NULL;
31087 }
31088
31089
31090 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31091 PyObject *resultobj = 0;
31092 wxWindow *arg1 = (wxWindow *) 0 ;
31093 int arg2 ;
31094 int arg3 ;
31095 int arg4 = (int) wxSIZE_USE_EXISTING ;
31096 void *argp1 = 0 ;
31097 int res1 = 0 ;
31098 int val2 ;
31099 int ecode2 = 0 ;
31100 int val3 ;
31101 int ecode3 = 0 ;
31102 int val4 ;
31103 int ecode4 = 0 ;
31104 PyObject * obj0 = 0 ;
31105 PyObject * obj1 = 0 ;
31106 PyObject * obj2 = 0 ;
31107 PyObject * obj3 = 0 ;
31108 char * kwnames[] = {
31109 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31110 };
31111
31112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 ecode2 = SWIG_AsVal_int(obj1, &val2);
31119 if (!SWIG_IsOK(ecode2)) {
31120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31121 }
31122 arg2 = static_cast< int >(val2);
31123 ecode3 = SWIG_AsVal_int(obj2, &val3);
31124 if (!SWIG_IsOK(ecode3)) {
31125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31126 }
31127 arg3 = static_cast< int >(val3);
31128 if (obj3) {
31129 ecode4 = SWIG_AsVal_int(obj3, &val4);
31130 if (!SWIG_IsOK(ecode4)) {
31131 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31132 }
31133 arg4 = static_cast< int >(val4);
31134 }
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 (arg1)->Move(arg2,arg3,arg4);
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_Py_Void();
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxWindow *arg1 = (wxWindow *) 0 ;
31151 wxSize const &arg2_defvalue = wxDefaultSize ;
31152 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31153 void *argp1 = 0 ;
31154 int res1 = 0 ;
31155 wxSize temp2 ;
31156 PyObject * obj0 = 0 ;
31157 PyObject * obj1 = 0 ;
31158 char * kwnames[] = {
31159 (char *) "self",(char *) "size", NULL
31160 };
31161
31162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31164 if (!SWIG_IsOK(res1)) {
31165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31166 }
31167 arg1 = reinterpret_cast< wxWindow * >(argp1);
31168 if (obj1) {
31169 {
31170 arg2 = &temp2;
31171 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31172 }
31173 }
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 resultobj = SWIG_Py_Void();
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31188 PyObject *resultobj = 0;
31189 wxWindow *arg1 = (wxWindow *) 0 ;
31190 void *argp1 = 0 ;
31191 int res1 = 0 ;
31192 PyObject *swig_obj[1] ;
31193
31194 if (!args) SWIG_fail;
31195 swig_obj[0] = args;
31196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31197 if (!SWIG_IsOK(res1)) {
31198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31199 }
31200 arg1 = reinterpret_cast< wxWindow * >(argp1);
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 (arg1)->Raise();
31204 wxPyEndAllowThreads(__tstate);
31205 if (PyErr_Occurred()) SWIG_fail;
31206 }
31207 resultobj = SWIG_Py_Void();
31208 return resultobj;
31209 fail:
31210 return NULL;
31211 }
31212
31213
31214 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31215 PyObject *resultobj = 0;
31216 wxWindow *arg1 = (wxWindow *) 0 ;
31217 void *argp1 = 0 ;
31218 int res1 = 0 ;
31219 PyObject *swig_obj[1] ;
31220
31221 if (!args) SWIG_fail;
31222 swig_obj[0] = args;
31223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31224 if (!SWIG_IsOK(res1)) {
31225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31226 }
31227 arg1 = reinterpret_cast< wxWindow * >(argp1);
31228 {
31229 PyThreadState* __tstate = wxPyBeginAllowThreads();
31230 (arg1)->Lower();
31231 wxPyEndAllowThreads(__tstate);
31232 if (PyErr_Occurred()) SWIG_fail;
31233 }
31234 resultobj = SWIG_Py_Void();
31235 return resultobj;
31236 fail:
31237 return NULL;
31238 }
31239
31240
31241 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31242 PyObject *resultobj = 0;
31243 wxWindow *arg1 = (wxWindow *) 0 ;
31244 wxSize *arg2 = 0 ;
31245 void *argp1 = 0 ;
31246 int res1 = 0 ;
31247 wxSize temp2 ;
31248 PyObject * obj0 = 0 ;
31249 PyObject * obj1 = 0 ;
31250 char * kwnames[] = {
31251 (char *) "self",(char *) "size", NULL
31252 };
31253
31254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31256 if (!SWIG_IsOK(res1)) {
31257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31258 }
31259 arg1 = reinterpret_cast< wxWindow * >(argp1);
31260 {
31261 arg2 = &temp2;
31262 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31263 }
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 (arg1)->SetClientSize((wxSize const &)*arg2);
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_Py_Void();
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj = 0;
31279 wxWindow *arg1 = (wxWindow *) 0 ;
31280 int arg2 ;
31281 int arg3 ;
31282 void *argp1 = 0 ;
31283 int res1 = 0 ;
31284 int val2 ;
31285 int ecode2 = 0 ;
31286 int val3 ;
31287 int ecode3 = 0 ;
31288 PyObject * obj0 = 0 ;
31289 PyObject * obj1 = 0 ;
31290 PyObject * obj2 = 0 ;
31291 char * kwnames[] = {
31292 (char *) "self",(char *) "width",(char *) "height", NULL
31293 };
31294
31295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31297 if (!SWIG_IsOK(res1)) {
31298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31299 }
31300 arg1 = reinterpret_cast< wxWindow * >(argp1);
31301 ecode2 = SWIG_AsVal_int(obj1, &val2);
31302 if (!SWIG_IsOK(ecode2)) {
31303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31304 }
31305 arg2 = static_cast< int >(val2);
31306 ecode3 = SWIG_AsVal_int(obj2, &val3);
31307 if (!SWIG_IsOK(ecode3)) {
31308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31309 }
31310 arg3 = static_cast< int >(val3);
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 (arg1)->SetClientSize(arg2,arg3);
31314 wxPyEndAllowThreads(__tstate);
31315 if (PyErr_Occurred()) SWIG_fail;
31316 }
31317 resultobj = SWIG_Py_Void();
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31325 PyObject *resultobj = 0;
31326 wxWindow *arg1 = (wxWindow *) 0 ;
31327 wxRect *arg2 = 0 ;
31328 void *argp1 = 0 ;
31329 int res1 = 0 ;
31330 wxRect temp2 ;
31331 PyObject * obj0 = 0 ;
31332 PyObject * obj1 = 0 ;
31333 char * kwnames[] = {
31334 (char *) "self",(char *) "rect", NULL
31335 };
31336
31337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31339 if (!SWIG_IsOK(res1)) {
31340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31341 }
31342 arg1 = reinterpret_cast< wxWindow * >(argp1);
31343 {
31344 arg2 = &temp2;
31345 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31346 }
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 (arg1)->SetClientSize((wxRect const &)*arg2);
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 resultobj = SWIG_Py_Void();
31354 return resultobj;
31355 fail:
31356 return NULL;
31357 }
31358
31359
31360 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31361 PyObject *resultobj = 0;
31362 wxWindow *arg1 = (wxWindow *) 0 ;
31363 wxPoint result;
31364 void *argp1 = 0 ;
31365 int res1 = 0 ;
31366 PyObject *swig_obj[1] ;
31367
31368 if (!args) SWIG_fail;
31369 swig_obj[0] = args;
31370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31371 if (!SWIG_IsOK(res1)) {
31372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31373 }
31374 arg1 = reinterpret_cast< wxWindow * >(argp1);
31375 {
31376 PyThreadState* __tstate = wxPyBeginAllowThreads();
31377 result = ((wxWindow const *)arg1)->GetPosition();
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31389 PyObject *resultobj = 0;
31390 wxWindow *arg1 = (wxWindow *) 0 ;
31391 int *arg2 = (int *) 0 ;
31392 int *arg3 = (int *) 0 ;
31393 void *argp1 = 0 ;
31394 int res1 = 0 ;
31395 int temp2 ;
31396 int res2 = SWIG_TMPOBJ ;
31397 int temp3 ;
31398 int res3 = SWIG_TMPOBJ ;
31399 PyObject *swig_obj[1] ;
31400
31401 arg2 = &temp2;
31402 arg3 = &temp3;
31403 if (!args) SWIG_fail;
31404 swig_obj[0] = args;
31405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31406 if (!SWIG_IsOK(res1)) {
31407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31408 }
31409 arg1 = reinterpret_cast< wxWindow * >(argp1);
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31413 wxPyEndAllowThreads(__tstate);
31414 if (PyErr_Occurred()) SWIG_fail;
31415 }
31416 resultobj = SWIG_Py_Void();
31417 if (SWIG_IsTmpObj(res2)) {
31418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31419 } else {
31420 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31422 }
31423 if (SWIG_IsTmpObj(res3)) {
31424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31425 } else {
31426 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31428 }
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 PyObject *resultobj = 0;
31437 wxWindow *arg1 = (wxWindow *) 0 ;
31438 wxPoint result;
31439 void *argp1 = 0 ;
31440 int res1 = 0 ;
31441 PyObject *swig_obj[1] ;
31442
31443 if (!args) SWIG_fail;
31444 swig_obj[0] = args;
31445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31446 if (!SWIG_IsOK(res1)) {
31447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31448 }
31449 arg1 = reinterpret_cast< wxWindow * >(argp1);
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = ((wxWindow const *)arg1)->GetScreenPosition();
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31464 PyObject *resultobj = 0;
31465 wxWindow *arg1 = (wxWindow *) 0 ;
31466 int *arg2 = (int *) 0 ;
31467 int *arg3 = (int *) 0 ;
31468 void *argp1 = 0 ;
31469 int res1 = 0 ;
31470 int temp2 ;
31471 int res2 = SWIG_TMPOBJ ;
31472 int temp3 ;
31473 int res3 = SWIG_TMPOBJ ;
31474 PyObject *swig_obj[1] ;
31475
31476 arg2 = &temp2;
31477 arg3 = &temp3;
31478 if (!args) SWIG_fail;
31479 swig_obj[0] = args;
31480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31481 if (!SWIG_IsOK(res1)) {
31482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31483 }
31484 arg1 = reinterpret_cast< wxWindow * >(argp1);
31485 {
31486 PyThreadState* __tstate = wxPyBeginAllowThreads();
31487 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 resultobj = SWIG_Py_Void();
31492 if (SWIG_IsTmpObj(res2)) {
31493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31494 } else {
31495 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31497 }
31498 if (SWIG_IsTmpObj(res3)) {
31499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31500 } else {
31501 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31503 }
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31511 PyObject *resultobj = 0;
31512 wxWindow *arg1 = (wxWindow *) 0 ;
31513 wxRect result;
31514 void *argp1 = 0 ;
31515 int res1 = 0 ;
31516 PyObject *swig_obj[1] ;
31517
31518 if (!args) SWIG_fail;
31519 swig_obj[0] = args;
31520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31521 if (!SWIG_IsOK(res1)) {
31522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31523 }
31524 arg1 = reinterpret_cast< wxWindow * >(argp1);
31525 {
31526 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 result = ((wxWindow const *)arg1)->GetScreenRect();
31528 wxPyEndAllowThreads(__tstate);
31529 if (PyErr_Occurred()) SWIG_fail;
31530 }
31531 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31539 PyObject *resultobj = 0;
31540 wxWindow *arg1 = (wxWindow *) 0 ;
31541 wxSize result;
31542 void *argp1 = 0 ;
31543 int res1 = 0 ;
31544 PyObject *swig_obj[1] ;
31545
31546 if (!args) SWIG_fail;
31547 swig_obj[0] = args;
31548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31549 if (!SWIG_IsOK(res1)) {
31550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31551 }
31552 arg1 = reinterpret_cast< wxWindow * >(argp1);
31553 {
31554 PyThreadState* __tstate = wxPyBeginAllowThreads();
31555 result = ((wxWindow const *)arg1)->GetSize();
31556 wxPyEndAllowThreads(__tstate);
31557 if (PyErr_Occurred()) SWIG_fail;
31558 }
31559 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31560 return resultobj;
31561 fail:
31562 return NULL;
31563 }
31564
31565
31566 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31567 PyObject *resultobj = 0;
31568 wxWindow *arg1 = (wxWindow *) 0 ;
31569 int *arg2 = (int *) 0 ;
31570 int *arg3 = (int *) 0 ;
31571 void *argp1 = 0 ;
31572 int res1 = 0 ;
31573 int temp2 ;
31574 int res2 = SWIG_TMPOBJ ;
31575 int temp3 ;
31576 int res3 = SWIG_TMPOBJ ;
31577 PyObject *swig_obj[1] ;
31578
31579 arg2 = &temp2;
31580 arg3 = &temp3;
31581 if (!args) SWIG_fail;
31582 swig_obj[0] = args;
31583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31584 if (!SWIG_IsOK(res1)) {
31585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31586 }
31587 arg1 = reinterpret_cast< wxWindow * >(argp1);
31588 {
31589 PyThreadState* __tstate = wxPyBeginAllowThreads();
31590 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31591 wxPyEndAllowThreads(__tstate);
31592 if (PyErr_Occurred()) SWIG_fail;
31593 }
31594 resultobj = SWIG_Py_Void();
31595 if (SWIG_IsTmpObj(res2)) {
31596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31597 } else {
31598 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31600 }
31601 if (SWIG_IsTmpObj(res3)) {
31602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31603 } else {
31604 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31606 }
31607 return resultobj;
31608 fail:
31609 return NULL;
31610 }
31611
31612
31613 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31614 PyObject *resultobj = 0;
31615 wxWindow *arg1 = (wxWindow *) 0 ;
31616 wxRect result;
31617 void *argp1 = 0 ;
31618 int res1 = 0 ;
31619 PyObject *swig_obj[1] ;
31620
31621 if (!args) SWIG_fail;
31622 swig_obj[0] = args;
31623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31624 if (!SWIG_IsOK(res1)) {
31625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31626 }
31627 arg1 = reinterpret_cast< wxWindow * >(argp1);
31628 {
31629 PyThreadState* __tstate = wxPyBeginAllowThreads();
31630 result = ((wxWindow const *)arg1)->GetRect();
31631 wxPyEndAllowThreads(__tstate);
31632 if (PyErr_Occurred()) SWIG_fail;
31633 }
31634 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31635 return resultobj;
31636 fail:
31637 return NULL;
31638 }
31639
31640
31641 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31642 PyObject *resultobj = 0;
31643 wxWindow *arg1 = (wxWindow *) 0 ;
31644 wxSize result;
31645 void *argp1 = 0 ;
31646 int res1 = 0 ;
31647 PyObject *swig_obj[1] ;
31648
31649 if (!args) SWIG_fail;
31650 swig_obj[0] = args;
31651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31652 if (!SWIG_IsOK(res1)) {
31653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31654 }
31655 arg1 = reinterpret_cast< wxWindow * >(argp1);
31656 {
31657 PyThreadState* __tstate = wxPyBeginAllowThreads();
31658 result = ((wxWindow const *)arg1)->GetClientSize();
31659 wxPyEndAllowThreads(__tstate);
31660 if (PyErr_Occurred()) SWIG_fail;
31661 }
31662 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31663 return resultobj;
31664 fail:
31665 return NULL;
31666 }
31667
31668
31669 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31670 PyObject *resultobj = 0;
31671 wxWindow *arg1 = (wxWindow *) 0 ;
31672 int *arg2 = (int *) 0 ;
31673 int *arg3 = (int *) 0 ;
31674 void *argp1 = 0 ;
31675 int res1 = 0 ;
31676 int temp2 ;
31677 int res2 = SWIG_TMPOBJ ;
31678 int temp3 ;
31679 int res3 = SWIG_TMPOBJ ;
31680 PyObject *swig_obj[1] ;
31681
31682 arg2 = &temp2;
31683 arg3 = &temp3;
31684 if (!args) SWIG_fail;
31685 swig_obj[0] = args;
31686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31689 }
31690 arg1 = reinterpret_cast< wxWindow * >(argp1);
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31694 wxPyEndAllowThreads(__tstate);
31695 if (PyErr_Occurred()) SWIG_fail;
31696 }
31697 resultobj = SWIG_Py_Void();
31698 if (SWIG_IsTmpObj(res2)) {
31699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31700 } else {
31701 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31703 }
31704 if (SWIG_IsTmpObj(res3)) {
31705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31706 } else {
31707 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31717 PyObject *resultobj = 0;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 wxPoint result;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 PyObject *swig_obj[1] ;
31723
31724 if (!args) SWIG_fail;
31725 swig_obj[0] = args;
31726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31727 if (!SWIG_IsOK(res1)) {
31728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31729 }
31730 arg1 = reinterpret_cast< wxWindow * >(argp1);
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31734 wxPyEndAllowThreads(__tstate);
31735 if (PyErr_Occurred()) SWIG_fail;
31736 }
31737 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31738 return resultobj;
31739 fail:
31740 return NULL;
31741 }
31742
31743
31744 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31745 PyObject *resultobj = 0;
31746 wxWindow *arg1 = (wxWindow *) 0 ;
31747 wxRect result;
31748 void *argp1 = 0 ;
31749 int res1 = 0 ;
31750 PyObject *swig_obj[1] ;
31751
31752 if (!args) SWIG_fail;
31753 swig_obj[0] = args;
31754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31755 if (!SWIG_IsOK(res1)) {
31756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31757 }
31758 arg1 = reinterpret_cast< wxWindow * >(argp1);
31759 {
31760 PyThreadState* __tstate = wxPyBeginAllowThreads();
31761 result = ((wxWindow const *)arg1)->GetClientRect();
31762 wxPyEndAllowThreads(__tstate);
31763 if (PyErr_Occurred()) SWIG_fail;
31764 }
31765 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31766 return resultobj;
31767 fail:
31768 return NULL;
31769 }
31770
31771
31772 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31773 PyObject *resultobj = 0;
31774 wxWindow *arg1 = (wxWindow *) 0 ;
31775 wxSize result;
31776 void *argp1 = 0 ;
31777 int res1 = 0 ;
31778 PyObject *swig_obj[1] ;
31779
31780 if (!args) SWIG_fail;
31781 swig_obj[0] = args;
31782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31783 if (!SWIG_IsOK(res1)) {
31784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31785 }
31786 arg1 = reinterpret_cast< wxWindow * >(argp1);
31787 {
31788 PyThreadState* __tstate = wxPyBeginAllowThreads();
31789 result = ((wxWindow const *)arg1)->GetBestSize();
31790 wxPyEndAllowThreads(__tstate);
31791 if (PyErr_Occurred()) SWIG_fail;
31792 }
31793 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31794 return resultobj;
31795 fail:
31796 return NULL;
31797 }
31798
31799
31800 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31801 PyObject *resultobj = 0;
31802 wxWindow *arg1 = (wxWindow *) 0 ;
31803 int *arg2 = (int *) 0 ;
31804 int *arg3 = (int *) 0 ;
31805 void *argp1 = 0 ;
31806 int res1 = 0 ;
31807 int temp2 ;
31808 int res2 = SWIG_TMPOBJ ;
31809 int temp3 ;
31810 int res3 = SWIG_TMPOBJ ;
31811 PyObject *swig_obj[1] ;
31812
31813 arg2 = &temp2;
31814 arg3 = &temp3;
31815 if (!args) SWIG_fail;
31816 swig_obj[0] = args;
31817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31818 if (!SWIG_IsOK(res1)) {
31819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31820 }
31821 arg1 = reinterpret_cast< wxWindow * >(argp1);
31822 {
31823 PyThreadState* __tstate = wxPyBeginAllowThreads();
31824 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_Py_Void();
31829 if (SWIG_IsTmpObj(res2)) {
31830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31831 } else {
31832 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31834 }
31835 if (SWIG_IsTmpObj(res3)) {
31836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31837 } else {
31838 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31840 }
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31848 PyObject *resultobj = 0;
31849 wxWindow *arg1 = (wxWindow *) 0 ;
31850 void *argp1 = 0 ;
31851 int res1 = 0 ;
31852 PyObject *swig_obj[1] ;
31853
31854 if (!args) SWIG_fail;
31855 swig_obj[0] = args;
31856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31859 }
31860 arg1 = reinterpret_cast< wxWindow * >(argp1);
31861 {
31862 PyThreadState* __tstate = wxPyBeginAllowThreads();
31863 (arg1)->InvalidateBestSize();
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 resultobj = SWIG_Py_Void();
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31875 PyObject *resultobj = 0;
31876 wxWindow *arg1 = (wxWindow *) 0 ;
31877 wxSize *arg2 = 0 ;
31878 void *argp1 = 0 ;
31879 int res1 = 0 ;
31880 wxSize temp2 ;
31881 PyObject * obj0 = 0 ;
31882 PyObject * obj1 = 0 ;
31883 char * kwnames[] = {
31884 (char *) "self",(char *) "size", NULL
31885 };
31886
31887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31889 if (!SWIG_IsOK(res1)) {
31890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31891 }
31892 arg1 = reinterpret_cast< wxWindow * >(argp1);
31893 {
31894 arg2 = &temp2;
31895 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31896 }
31897 {
31898 PyThreadState* __tstate = wxPyBeginAllowThreads();
31899 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31900 wxPyEndAllowThreads(__tstate);
31901 if (PyErr_Occurred()) SWIG_fail;
31902 }
31903 resultobj = SWIG_Py_Void();
31904 return resultobj;
31905 fail:
31906 return NULL;
31907 }
31908
31909
31910 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31911 PyObject *resultobj = 0;
31912 wxWindow *arg1 = (wxWindow *) 0 ;
31913 wxSize result;
31914 void *argp1 = 0 ;
31915 int res1 = 0 ;
31916 PyObject *swig_obj[1] ;
31917
31918 if (!args) SWIG_fail;
31919 swig_obj[0] = args;
31920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31921 if (!SWIG_IsOK(res1)) {
31922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31923 }
31924 arg1 = reinterpret_cast< wxWindow * >(argp1);
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31939 PyObject *resultobj = 0;
31940 wxWindow *arg1 = (wxWindow *) 0 ;
31941 wxSize result;
31942 void *argp1 = 0 ;
31943 int res1 = 0 ;
31944 PyObject *swig_obj[1] ;
31945
31946 if (!args) SWIG_fail;
31947 swig_obj[0] = args;
31948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31949 if (!SWIG_IsOK(res1)) {
31950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31951 }
31952 arg1 = reinterpret_cast< wxWindow * >(argp1);
31953 {
31954 PyThreadState* __tstate = wxPyBeginAllowThreads();
31955 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31967 PyObject *resultobj = 0;
31968 wxWindow *arg1 = (wxWindow *) 0 ;
31969 int arg2 = (int) wxBOTH ;
31970 void *argp1 = 0 ;
31971 int res1 = 0 ;
31972 int val2 ;
31973 int ecode2 = 0 ;
31974 PyObject * obj0 = 0 ;
31975 PyObject * obj1 = 0 ;
31976 char * kwnames[] = {
31977 (char *) "self",(char *) "direction", NULL
31978 };
31979
31980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31982 if (!SWIG_IsOK(res1)) {
31983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31984 }
31985 arg1 = reinterpret_cast< wxWindow * >(argp1);
31986 if (obj1) {
31987 ecode2 = SWIG_AsVal_int(obj1, &val2);
31988 if (!SWIG_IsOK(ecode2)) {
31989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31990 }
31991 arg2 = static_cast< int >(val2);
31992 }
31993 {
31994 PyThreadState* __tstate = wxPyBeginAllowThreads();
31995 (arg1)->Center(arg2);
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 resultobj = SWIG_Py_Void();
32000 return resultobj;
32001 fail:
32002 return NULL;
32003 }
32004
32005
32006 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32007 PyObject *resultobj = 0;
32008 wxWindow *arg1 = (wxWindow *) 0 ;
32009 int arg2 = (int) wxBOTH ;
32010 void *argp1 = 0 ;
32011 int res1 = 0 ;
32012 int val2 ;
32013 int ecode2 = 0 ;
32014 PyObject * obj0 = 0 ;
32015 PyObject * obj1 = 0 ;
32016 char * kwnames[] = {
32017 (char *) "self",(char *) "dir", NULL
32018 };
32019
32020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32022 if (!SWIG_IsOK(res1)) {
32023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32024 }
32025 arg1 = reinterpret_cast< wxWindow * >(argp1);
32026 if (obj1) {
32027 ecode2 = SWIG_AsVal_int(obj1, &val2);
32028 if (!SWIG_IsOK(ecode2)) {
32029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32030 }
32031 arg2 = static_cast< int >(val2);
32032 }
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 (arg1)->CenterOnParent(arg2);
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_Py_Void();
32040 return resultobj;
32041 fail:
32042 return NULL;
32043 }
32044
32045
32046 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32047 PyObject *resultobj = 0;
32048 wxWindow *arg1 = (wxWindow *) 0 ;
32049 void *argp1 = 0 ;
32050 int res1 = 0 ;
32051 PyObject *swig_obj[1] ;
32052
32053 if (!args) SWIG_fail;
32054 swig_obj[0] = args;
32055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32056 if (!SWIG_IsOK(res1)) {
32057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32058 }
32059 arg1 = reinterpret_cast< wxWindow * >(argp1);
32060 {
32061 PyThreadState* __tstate = wxPyBeginAllowThreads();
32062 (arg1)->Fit();
32063 wxPyEndAllowThreads(__tstate);
32064 if (PyErr_Occurred()) SWIG_fail;
32065 }
32066 resultobj = SWIG_Py_Void();
32067 return resultobj;
32068 fail:
32069 return NULL;
32070 }
32071
32072
32073 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32074 PyObject *resultobj = 0;
32075 wxWindow *arg1 = (wxWindow *) 0 ;
32076 void *argp1 = 0 ;
32077 int res1 = 0 ;
32078 PyObject *swig_obj[1] ;
32079
32080 if (!args) SWIG_fail;
32081 swig_obj[0] = args;
32082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32083 if (!SWIG_IsOK(res1)) {
32084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32085 }
32086 arg1 = reinterpret_cast< wxWindow * >(argp1);
32087 {
32088 PyThreadState* __tstate = wxPyBeginAllowThreads();
32089 (arg1)->FitInside();
32090 wxPyEndAllowThreads(__tstate);
32091 if (PyErr_Occurred()) SWIG_fail;
32092 }
32093 resultobj = SWIG_Py_Void();
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj = 0;
32102 wxWindow *arg1 = (wxWindow *) 0 ;
32103 int arg2 ;
32104 int arg3 ;
32105 int arg4 = (int) -1 ;
32106 int arg5 = (int) -1 ;
32107 int arg6 = (int) -1 ;
32108 int arg7 = (int) -1 ;
32109 void *argp1 = 0 ;
32110 int res1 = 0 ;
32111 int val2 ;
32112 int ecode2 = 0 ;
32113 int val3 ;
32114 int ecode3 = 0 ;
32115 int val4 ;
32116 int ecode4 = 0 ;
32117 int val5 ;
32118 int ecode5 = 0 ;
32119 int val6 ;
32120 int ecode6 = 0 ;
32121 int val7 ;
32122 int ecode7 = 0 ;
32123 PyObject * obj0 = 0 ;
32124 PyObject * obj1 = 0 ;
32125 PyObject * obj2 = 0 ;
32126 PyObject * obj3 = 0 ;
32127 PyObject * obj4 = 0 ;
32128 PyObject * obj5 = 0 ;
32129 PyObject * obj6 = 0 ;
32130 char * kwnames[] = {
32131 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32132 };
32133
32134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32136 if (!SWIG_IsOK(res1)) {
32137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32138 }
32139 arg1 = reinterpret_cast< wxWindow * >(argp1);
32140 ecode2 = SWIG_AsVal_int(obj1, &val2);
32141 if (!SWIG_IsOK(ecode2)) {
32142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32143 }
32144 arg2 = static_cast< int >(val2);
32145 ecode3 = SWIG_AsVal_int(obj2, &val3);
32146 if (!SWIG_IsOK(ecode3)) {
32147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32148 }
32149 arg3 = static_cast< int >(val3);
32150 if (obj3) {
32151 ecode4 = SWIG_AsVal_int(obj3, &val4);
32152 if (!SWIG_IsOK(ecode4)) {
32153 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32154 }
32155 arg4 = static_cast< int >(val4);
32156 }
32157 if (obj4) {
32158 ecode5 = SWIG_AsVal_int(obj4, &val5);
32159 if (!SWIG_IsOK(ecode5)) {
32160 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32161 }
32162 arg5 = static_cast< int >(val5);
32163 }
32164 if (obj5) {
32165 ecode6 = SWIG_AsVal_int(obj5, &val6);
32166 if (!SWIG_IsOK(ecode6)) {
32167 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32168 }
32169 arg6 = static_cast< int >(val6);
32170 }
32171 if (obj6) {
32172 ecode7 = SWIG_AsVal_int(obj6, &val7);
32173 if (!SWIG_IsOK(ecode7)) {
32174 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32175 }
32176 arg7 = static_cast< int >(val7);
32177 }
32178 {
32179 PyThreadState* __tstate = wxPyBeginAllowThreads();
32180 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32181 wxPyEndAllowThreads(__tstate);
32182 if (PyErr_Occurred()) SWIG_fail;
32183 }
32184 resultobj = SWIG_Py_Void();
32185 return resultobj;
32186 fail:
32187 return NULL;
32188 }
32189
32190
32191 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32192 PyObject *resultobj = 0;
32193 wxWindow *arg1 = (wxWindow *) 0 ;
32194 wxSize *arg2 = 0 ;
32195 wxSize const &arg3_defvalue = wxDefaultSize ;
32196 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32197 wxSize const &arg4_defvalue = wxDefaultSize ;
32198 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32199 void *argp1 = 0 ;
32200 int res1 = 0 ;
32201 wxSize temp2 ;
32202 wxSize temp3 ;
32203 wxSize temp4 ;
32204 PyObject * obj0 = 0 ;
32205 PyObject * obj1 = 0 ;
32206 PyObject * obj2 = 0 ;
32207 PyObject * obj3 = 0 ;
32208 char * kwnames[] = {
32209 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32210 };
32211
32212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32214 if (!SWIG_IsOK(res1)) {
32215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32216 }
32217 arg1 = reinterpret_cast< wxWindow * >(argp1);
32218 {
32219 arg2 = &temp2;
32220 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32221 }
32222 if (obj2) {
32223 {
32224 arg3 = &temp3;
32225 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32226 }
32227 }
32228 if (obj3) {
32229 {
32230 arg4 = &temp4;
32231 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32232 }
32233 }
32234 {
32235 PyThreadState* __tstate = wxPyBeginAllowThreads();
32236 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 resultobj = SWIG_Py_Void();
32241 return resultobj;
32242 fail:
32243 return NULL;
32244 }
32245
32246
32247 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32248 PyObject *resultobj = 0;
32249 wxWindow *arg1 = (wxWindow *) 0 ;
32250 int arg2 ;
32251 int arg3 ;
32252 int arg4 = (int) -1 ;
32253 int arg5 = (int) -1 ;
32254 void *argp1 = 0 ;
32255 int res1 = 0 ;
32256 int val2 ;
32257 int ecode2 = 0 ;
32258 int val3 ;
32259 int ecode3 = 0 ;
32260 int val4 ;
32261 int ecode4 = 0 ;
32262 int val5 ;
32263 int ecode5 = 0 ;
32264 PyObject * obj0 = 0 ;
32265 PyObject * obj1 = 0 ;
32266 PyObject * obj2 = 0 ;
32267 PyObject * obj3 = 0 ;
32268 PyObject * obj4 = 0 ;
32269 char * kwnames[] = {
32270 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32271 };
32272
32273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32275 if (!SWIG_IsOK(res1)) {
32276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32277 }
32278 arg1 = reinterpret_cast< wxWindow * >(argp1);
32279 ecode2 = SWIG_AsVal_int(obj1, &val2);
32280 if (!SWIG_IsOK(ecode2)) {
32281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32282 }
32283 arg2 = static_cast< int >(val2);
32284 ecode3 = SWIG_AsVal_int(obj2, &val3);
32285 if (!SWIG_IsOK(ecode3)) {
32286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32287 }
32288 arg3 = static_cast< int >(val3);
32289 if (obj3) {
32290 ecode4 = SWIG_AsVal_int(obj3, &val4);
32291 if (!SWIG_IsOK(ecode4)) {
32292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32293 }
32294 arg4 = static_cast< int >(val4);
32295 }
32296 if (obj4) {
32297 ecode5 = SWIG_AsVal_int(obj4, &val5);
32298 if (!SWIG_IsOK(ecode5)) {
32299 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32300 }
32301 arg5 = static_cast< int >(val5);
32302 }
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 resultobj = SWIG_Py_Void();
32310 return resultobj;
32311 fail:
32312 return NULL;
32313 }
32314
32315
32316 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32317 PyObject *resultobj = 0;
32318 wxWindow *arg1 = (wxWindow *) 0 ;
32319 wxSize *arg2 = 0 ;
32320 wxSize const &arg3_defvalue = wxDefaultSize ;
32321 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32322 void *argp1 = 0 ;
32323 int res1 = 0 ;
32324 wxSize temp2 ;
32325 wxSize temp3 ;
32326 PyObject * obj0 = 0 ;
32327 PyObject * obj1 = 0 ;
32328 PyObject * obj2 = 0 ;
32329 char * kwnames[] = {
32330 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32331 };
32332
32333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32335 if (!SWIG_IsOK(res1)) {
32336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32337 }
32338 arg1 = reinterpret_cast< wxWindow * >(argp1);
32339 {
32340 arg2 = &temp2;
32341 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32342 }
32343 if (obj2) {
32344 {
32345 arg3 = &temp3;
32346 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32347 }
32348 }
32349 {
32350 PyThreadState* __tstate = wxPyBeginAllowThreads();
32351 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32352 wxPyEndAllowThreads(__tstate);
32353 if (PyErr_Occurred()) SWIG_fail;
32354 }
32355 resultobj = SWIG_Py_Void();
32356 return resultobj;
32357 fail:
32358 return NULL;
32359 }
32360
32361
32362 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32363 PyObject *resultobj = 0;
32364 wxWindow *arg1 = (wxWindow *) 0 ;
32365 wxSize result;
32366 void *argp1 = 0 ;
32367 int res1 = 0 ;
32368 PyObject *swig_obj[1] ;
32369
32370 if (!args) SWIG_fail;
32371 swig_obj[0] = args;
32372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32373 if (!SWIG_IsOK(res1)) {
32374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32375 }
32376 arg1 = reinterpret_cast< wxWindow * >(argp1);
32377 {
32378 PyThreadState* __tstate = wxPyBeginAllowThreads();
32379 result = ((wxWindow const *)arg1)->GetMaxSize();
32380 wxPyEndAllowThreads(__tstate);
32381 if (PyErr_Occurred()) SWIG_fail;
32382 }
32383 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32384 return resultobj;
32385 fail:
32386 return NULL;
32387 }
32388
32389
32390 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32391 PyObject *resultobj = 0;
32392 wxWindow *arg1 = (wxWindow *) 0 ;
32393 wxSize result;
32394 void *argp1 = 0 ;
32395 int res1 = 0 ;
32396 PyObject *swig_obj[1] ;
32397
32398 if (!args) SWIG_fail;
32399 swig_obj[0] = args;
32400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32401 if (!SWIG_IsOK(res1)) {
32402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32403 }
32404 arg1 = reinterpret_cast< wxWindow * >(argp1);
32405 {
32406 PyThreadState* __tstate = wxPyBeginAllowThreads();
32407 result = ((wxWindow const *)arg1)->GetMinSize();
32408 wxPyEndAllowThreads(__tstate);
32409 if (PyErr_Occurred()) SWIG_fail;
32410 }
32411 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32412 return resultobj;
32413 fail:
32414 return NULL;
32415 }
32416
32417
32418 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32419 PyObject *resultobj = 0;
32420 wxWindow *arg1 = (wxWindow *) 0 ;
32421 wxSize *arg2 = 0 ;
32422 void *argp1 = 0 ;
32423 int res1 = 0 ;
32424 wxSize temp2 ;
32425 PyObject * obj0 = 0 ;
32426 PyObject * obj1 = 0 ;
32427 char * kwnames[] = {
32428 (char *) "self",(char *) "minSize", NULL
32429 };
32430
32431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32433 if (!SWIG_IsOK(res1)) {
32434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32435 }
32436 arg1 = reinterpret_cast< wxWindow * >(argp1);
32437 {
32438 arg2 = &temp2;
32439 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32440 }
32441 {
32442 PyThreadState* __tstate = wxPyBeginAllowThreads();
32443 (arg1)->SetMinSize((wxSize const &)*arg2);
32444 wxPyEndAllowThreads(__tstate);
32445 if (PyErr_Occurred()) SWIG_fail;
32446 }
32447 resultobj = SWIG_Py_Void();
32448 return resultobj;
32449 fail:
32450 return NULL;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32455 PyObject *resultobj = 0;
32456 wxWindow *arg1 = (wxWindow *) 0 ;
32457 wxSize *arg2 = 0 ;
32458 void *argp1 = 0 ;
32459 int res1 = 0 ;
32460 wxSize temp2 ;
32461 PyObject * obj0 = 0 ;
32462 PyObject * obj1 = 0 ;
32463 char * kwnames[] = {
32464 (char *) "self",(char *) "maxSize", NULL
32465 };
32466
32467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32469 if (!SWIG_IsOK(res1)) {
32470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32471 }
32472 arg1 = reinterpret_cast< wxWindow * >(argp1);
32473 {
32474 arg2 = &temp2;
32475 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32476 }
32477 {
32478 PyThreadState* __tstate = wxPyBeginAllowThreads();
32479 (arg1)->SetMaxSize((wxSize const &)*arg2);
32480 wxPyEndAllowThreads(__tstate);
32481 if (PyErr_Occurred()) SWIG_fail;
32482 }
32483 resultobj = SWIG_Py_Void();
32484 return resultobj;
32485 fail:
32486 return NULL;
32487 }
32488
32489
32490 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32491 PyObject *resultobj = 0;
32492 wxWindow *arg1 = (wxWindow *) 0 ;
32493 int result;
32494 void *argp1 = 0 ;
32495 int res1 = 0 ;
32496 PyObject *swig_obj[1] ;
32497
32498 if (!args) SWIG_fail;
32499 swig_obj[0] = args;
32500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32501 if (!SWIG_IsOK(res1)) {
32502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32503 }
32504 arg1 = reinterpret_cast< wxWindow * >(argp1);
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32508 wxPyEndAllowThreads(__tstate);
32509 if (PyErr_Occurred()) SWIG_fail;
32510 }
32511 resultobj = SWIG_From_int(static_cast< int >(result));
32512 return resultobj;
32513 fail:
32514 return NULL;
32515 }
32516
32517
32518 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32519 PyObject *resultobj = 0;
32520 wxWindow *arg1 = (wxWindow *) 0 ;
32521 int result;
32522 void *argp1 = 0 ;
32523 int res1 = 0 ;
32524 PyObject *swig_obj[1] ;
32525
32526 if (!args) SWIG_fail;
32527 swig_obj[0] = args;
32528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32529 if (!SWIG_IsOK(res1)) {
32530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32531 }
32532 arg1 = reinterpret_cast< wxWindow * >(argp1);
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 resultobj = SWIG_From_int(static_cast< int >(result));
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxWindow *arg1 = (wxWindow *) 0 ;
32549 int result;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32559 }
32560 arg1 = reinterpret_cast< wxWindow * >(argp1);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_From_int(static_cast< int >(result));
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32575 PyObject *resultobj = 0;
32576 wxWindow *arg1 = (wxWindow *) 0 ;
32577 int result;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 PyObject *swig_obj[1] ;
32581
32582 if (!args) SWIG_fail;
32583 swig_obj[0] = args;
32584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32585 if (!SWIG_IsOK(res1)) {
32586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32587 }
32588 arg1 = reinterpret_cast< wxWindow * >(argp1);
32589 {
32590 PyThreadState* __tstate = wxPyBeginAllowThreads();
32591 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 resultobj = SWIG_From_int(static_cast< int >(result));
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32603 PyObject *resultobj = 0;
32604 wxWindow *arg1 = (wxWindow *) 0 ;
32605 wxSize *arg2 = 0 ;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 wxSize temp2 ;
32609 PyObject * obj0 = 0 ;
32610 PyObject * obj1 = 0 ;
32611 char * kwnames[] = {
32612 (char *) "self",(char *) "size", NULL
32613 };
32614
32615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32617 if (!SWIG_IsOK(res1)) {
32618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32619 }
32620 arg1 = reinterpret_cast< wxWindow * >(argp1);
32621 {
32622 arg2 = &temp2;
32623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32624 }
32625 {
32626 PyThreadState* __tstate = wxPyBeginAllowThreads();
32627 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32628 wxPyEndAllowThreads(__tstate);
32629 if (PyErr_Occurred()) SWIG_fail;
32630 }
32631 resultobj = SWIG_Py_Void();
32632 return resultobj;
32633 fail:
32634 return NULL;
32635 }
32636
32637
32638 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32639 PyObject *resultobj = 0;
32640 wxWindow *arg1 = (wxWindow *) 0 ;
32641 int arg2 ;
32642 int arg3 ;
32643 void *argp1 = 0 ;
32644 int res1 = 0 ;
32645 int val2 ;
32646 int ecode2 = 0 ;
32647 int val3 ;
32648 int ecode3 = 0 ;
32649 PyObject * obj0 = 0 ;
32650 PyObject * obj1 = 0 ;
32651 PyObject * obj2 = 0 ;
32652 char * kwnames[] = {
32653 (char *) "self",(char *) "w",(char *) "h", NULL
32654 };
32655
32656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32658 if (!SWIG_IsOK(res1)) {
32659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32660 }
32661 arg1 = reinterpret_cast< wxWindow * >(argp1);
32662 ecode2 = SWIG_AsVal_int(obj1, &val2);
32663 if (!SWIG_IsOK(ecode2)) {
32664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32665 }
32666 arg2 = static_cast< int >(val2);
32667 ecode3 = SWIG_AsVal_int(obj2, &val3);
32668 if (!SWIG_IsOK(ecode3)) {
32669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32670 }
32671 arg3 = static_cast< int >(val3);
32672 {
32673 PyThreadState* __tstate = wxPyBeginAllowThreads();
32674 (arg1)->SetVirtualSize(arg2,arg3);
32675 wxPyEndAllowThreads(__tstate);
32676 if (PyErr_Occurred()) SWIG_fail;
32677 }
32678 resultobj = SWIG_Py_Void();
32679 return resultobj;
32680 fail:
32681 return NULL;
32682 }
32683
32684
32685 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32686 PyObject *resultobj = 0;
32687 wxWindow *arg1 = (wxWindow *) 0 ;
32688 wxSize result;
32689 void *argp1 = 0 ;
32690 int res1 = 0 ;
32691 PyObject *swig_obj[1] ;
32692
32693 if (!args) SWIG_fail;
32694 swig_obj[0] = args;
32695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32696 if (!SWIG_IsOK(res1)) {
32697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32698 }
32699 arg1 = reinterpret_cast< wxWindow * >(argp1);
32700 {
32701 PyThreadState* __tstate = wxPyBeginAllowThreads();
32702 result = ((wxWindow const *)arg1)->GetVirtualSize();
32703 wxPyEndAllowThreads(__tstate);
32704 if (PyErr_Occurred()) SWIG_fail;
32705 }
32706 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32707 return resultobj;
32708 fail:
32709 return NULL;
32710 }
32711
32712
32713 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32714 PyObject *resultobj = 0;
32715 wxWindow *arg1 = (wxWindow *) 0 ;
32716 int *arg2 = (int *) 0 ;
32717 int *arg3 = (int *) 0 ;
32718 void *argp1 = 0 ;
32719 int res1 = 0 ;
32720 int temp2 ;
32721 int res2 = SWIG_TMPOBJ ;
32722 int temp3 ;
32723 int res3 = SWIG_TMPOBJ ;
32724 PyObject *swig_obj[1] ;
32725
32726 arg2 = &temp2;
32727 arg3 = &temp3;
32728 if (!args) SWIG_fail;
32729 swig_obj[0] = args;
32730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32731 if (!SWIG_IsOK(res1)) {
32732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32733 }
32734 arg1 = reinterpret_cast< wxWindow * >(argp1);
32735 {
32736 PyThreadState* __tstate = wxPyBeginAllowThreads();
32737 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32738 wxPyEndAllowThreads(__tstate);
32739 if (PyErr_Occurred()) SWIG_fail;
32740 }
32741 resultobj = SWIG_Py_Void();
32742 if (SWIG_IsTmpObj(res2)) {
32743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32744 } else {
32745 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32747 }
32748 if (SWIG_IsTmpObj(res3)) {
32749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32750 } else {
32751 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32753 }
32754 return resultobj;
32755 fail:
32756 return NULL;
32757 }
32758
32759
32760 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32761 PyObject *resultobj = 0;
32762 wxWindow *arg1 = (wxWindow *) 0 ;
32763 wxSize result;
32764 void *argp1 = 0 ;
32765 int res1 = 0 ;
32766 PyObject *swig_obj[1] ;
32767
32768 if (!args) SWIG_fail;
32769 swig_obj[0] = args;
32770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32771 if (!SWIG_IsOK(res1)) {
32772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32773 }
32774 arg1 = reinterpret_cast< wxWindow * >(argp1);
32775 {
32776 PyThreadState* __tstate = wxPyBeginAllowThreads();
32777 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32782 return resultobj;
32783 fail:
32784 return NULL;
32785 }
32786
32787
32788 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32789 PyObject *resultobj = 0;
32790 wxWindow *arg1 = (wxWindow *) 0 ;
32791 bool arg2 = (bool) true ;
32792 bool result;
32793 void *argp1 = 0 ;
32794 int res1 = 0 ;
32795 bool val2 ;
32796 int ecode2 = 0 ;
32797 PyObject * obj0 = 0 ;
32798 PyObject * obj1 = 0 ;
32799 char * kwnames[] = {
32800 (char *) "self",(char *) "show", NULL
32801 };
32802
32803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 if (obj1) {
32810 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32811 if (!SWIG_IsOK(ecode2)) {
32812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32813 }
32814 arg2 = static_cast< bool >(val2);
32815 }
32816 {
32817 PyThreadState* __tstate = wxPyBeginAllowThreads();
32818 result = (bool)(arg1)->Show(arg2);
32819 wxPyEndAllowThreads(__tstate);
32820 if (PyErr_Occurred()) SWIG_fail;
32821 }
32822 {
32823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32824 }
32825 return resultobj;
32826 fail:
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32832 PyObject *resultobj = 0;
32833 wxWindow *arg1 = (wxWindow *) 0 ;
32834 bool result;
32835 void *argp1 = 0 ;
32836 int res1 = 0 ;
32837 PyObject *swig_obj[1] ;
32838
32839 if (!args) SWIG_fail;
32840 swig_obj[0] = args;
32841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32842 if (!SWIG_IsOK(res1)) {
32843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32844 }
32845 arg1 = reinterpret_cast< wxWindow * >(argp1);
32846 {
32847 PyThreadState* __tstate = wxPyBeginAllowThreads();
32848 result = (bool)(arg1)->Hide();
32849 wxPyEndAllowThreads(__tstate);
32850 if (PyErr_Occurred()) SWIG_fail;
32851 }
32852 {
32853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32854 }
32855 return resultobj;
32856 fail:
32857 return NULL;
32858 }
32859
32860
32861 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32862 PyObject *resultobj = 0;
32863 wxWindow *arg1 = (wxWindow *) 0 ;
32864 bool arg2 = (bool) true ;
32865 bool result;
32866 void *argp1 = 0 ;
32867 int res1 = 0 ;
32868 bool val2 ;
32869 int ecode2 = 0 ;
32870 PyObject * obj0 = 0 ;
32871 PyObject * obj1 = 0 ;
32872 char * kwnames[] = {
32873 (char *) "self",(char *) "enable", NULL
32874 };
32875
32876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32878 if (!SWIG_IsOK(res1)) {
32879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32880 }
32881 arg1 = reinterpret_cast< wxWindow * >(argp1);
32882 if (obj1) {
32883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32884 if (!SWIG_IsOK(ecode2)) {
32885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32886 }
32887 arg2 = static_cast< bool >(val2);
32888 }
32889 {
32890 PyThreadState* __tstate = wxPyBeginAllowThreads();
32891 result = (bool)(arg1)->Enable(arg2);
32892 wxPyEndAllowThreads(__tstate);
32893 if (PyErr_Occurred()) SWIG_fail;
32894 }
32895 {
32896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32897 }
32898 return resultobj;
32899 fail:
32900 return NULL;
32901 }
32902
32903
32904 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32905 PyObject *resultobj = 0;
32906 wxWindow *arg1 = (wxWindow *) 0 ;
32907 bool result;
32908 void *argp1 = 0 ;
32909 int res1 = 0 ;
32910 PyObject *swig_obj[1] ;
32911
32912 if (!args) SWIG_fail;
32913 swig_obj[0] = args;
32914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32917 }
32918 arg1 = reinterpret_cast< wxWindow * >(argp1);
32919 {
32920 PyThreadState* __tstate = wxPyBeginAllowThreads();
32921 result = (bool)(arg1)->Disable();
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 {
32926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32927 }
32928 return resultobj;
32929 fail:
32930 return NULL;
32931 }
32932
32933
32934 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32935 PyObject *resultobj = 0;
32936 wxWindow *arg1 = (wxWindow *) 0 ;
32937 bool result;
32938 void *argp1 = 0 ;
32939 int res1 = 0 ;
32940 PyObject *swig_obj[1] ;
32941
32942 if (!args) SWIG_fail;
32943 swig_obj[0] = args;
32944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32945 if (!SWIG_IsOK(res1)) {
32946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32947 }
32948 arg1 = reinterpret_cast< wxWindow * >(argp1);
32949 {
32950 PyThreadState* __tstate = wxPyBeginAllowThreads();
32951 result = (bool)((wxWindow const *)arg1)->IsShown();
32952 wxPyEndAllowThreads(__tstate);
32953 if (PyErr_Occurred()) SWIG_fail;
32954 }
32955 {
32956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32957 }
32958 return resultobj;
32959 fail:
32960 return NULL;
32961 }
32962
32963
32964 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32965 PyObject *resultobj = 0;
32966 wxWindow *arg1 = (wxWindow *) 0 ;
32967 bool result;
32968 void *argp1 = 0 ;
32969 int res1 = 0 ;
32970 PyObject *swig_obj[1] ;
32971
32972 if (!args) SWIG_fail;
32973 swig_obj[0] = args;
32974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32975 if (!SWIG_IsOK(res1)) {
32976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32977 }
32978 arg1 = reinterpret_cast< wxWindow * >(argp1);
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32982 wxPyEndAllowThreads(__tstate);
32983 if (PyErr_Occurred()) SWIG_fail;
32984 }
32985 {
32986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32987 }
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32995 PyObject *resultobj = 0;
32996 wxWindow *arg1 = (wxWindow *) 0 ;
32997 long arg2 ;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 long val2 ;
33001 int ecode2 = 0 ;
33002 PyObject * obj0 = 0 ;
33003 PyObject * obj1 = 0 ;
33004 char * kwnames[] = {
33005 (char *) "self",(char *) "style", NULL
33006 };
33007
33008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33010 if (!SWIG_IsOK(res1)) {
33011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33012 }
33013 arg1 = reinterpret_cast< wxWindow * >(argp1);
33014 ecode2 = SWIG_AsVal_long(obj1, &val2);
33015 if (!SWIG_IsOK(ecode2)) {
33016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33017 }
33018 arg2 = static_cast< long >(val2);
33019 {
33020 PyThreadState* __tstate = wxPyBeginAllowThreads();
33021 (arg1)->SetWindowStyleFlag(arg2);
33022 wxPyEndAllowThreads(__tstate);
33023 if (PyErr_Occurred()) SWIG_fail;
33024 }
33025 resultobj = SWIG_Py_Void();
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33033 PyObject *resultobj = 0;
33034 wxWindow *arg1 = (wxWindow *) 0 ;
33035 long result;
33036 void *argp1 = 0 ;
33037 int res1 = 0 ;
33038 PyObject *swig_obj[1] ;
33039
33040 if (!args) SWIG_fail;
33041 swig_obj[0] = args;
33042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33043 if (!SWIG_IsOK(res1)) {
33044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33045 }
33046 arg1 = reinterpret_cast< wxWindow * >(argp1);
33047 {
33048 PyThreadState* __tstate = wxPyBeginAllowThreads();
33049 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33050 wxPyEndAllowThreads(__tstate);
33051 if (PyErr_Occurred()) SWIG_fail;
33052 }
33053 resultobj = SWIG_From_long(static_cast< long >(result));
33054 return resultobj;
33055 fail:
33056 return NULL;
33057 }
33058
33059
33060 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33061 PyObject *resultobj = 0;
33062 wxWindow *arg1 = (wxWindow *) 0 ;
33063 int arg2 ;
33064 bool result;
33065 void *argp1 = 0 ;
33066 int res1 = 0 ;
33067 int val2 ;
33068 int ecode2 = 0 ;
33069 PyObject * obj0 = 0 ;
33070 PyObject * obj1 = 0 ;
33071 char * kwnames[] = {
33072 (char *) "self",(char *) "flag", NULL
33073 };
33074
33075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33077 if (!SWIG_IsOK(res1)) {
33078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33079 }
33080 arg1 = reinterpret_cast< wxWindow * >(argp1);
33081 ecode2 = SWIG_AsVal_int(obj1, &val2);
33082 if (!SWIG_IsOK(ecode2)) {
33083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33084 }
33085 arg2 = static_cast< int >(val2);
33086 {
33087 PyThreadState* __tstate = wxPyBeginAllowThreads();
33088 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33089 wxPyEndAllowThreads(__tstate);
33090 if (PyErr_Occurred()) SWIG_fail;
33091 }
33092 {
33093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33094 }
33095 return resultobj;
33096 fail:
33097 return NULL;
33098 }
33099
33100
33101 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33102 PyObject *resultobj = 0;
33103 wxWindow *arg1 = (wxWindow *) 0 ;
33104 bool result;
33105 void *argp1 = 0 ;
33106 int res1 = 0 ;
33107 PyObject *swig_obj[1] ;
33108
33109 if (!args) SWIG_fail;
33110 swig_obj[0] = args;
33111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33112 if (!SWIG_IsOK(res1)) {
33113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33114 }
33115 arg1 = reinterpret_cast< wxWindow * >(argp1);
33116 {
33117 PyThreadState* __tstate = wxPyBeginAllowThreads();
33118 result = (bool)((wxWindow const *)arg1)->IsRetained();
33119 wxPyEndAllowThreads(__tstate);
33120 if (PyErr_Occurred()) SWIG_fail;
33121 }
33122 {
33123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33124 }
33125 return resultobj;
33126 fail:
33127 return NULL;
33128 }
33129
33130
33131 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33132 PyObject *resultobj = 0;
33133 wxWindow *arg1 = (wxWindow *) 0 ;
33134 long arg2 ;
33135 void *argp1 = 0 ;
33136 int res1 = 0 ;
33137 long val2 ;
33138 int ecode2 = 0 ;
33139 PyObject * obj0 = 0 ;
33140 PyObject * obj1 = 0 ;
33141 char * kwnames[] = {
33142 (char *) "self",(char *) "exStyle", NULL
33143 };
33144
33145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33147 if (!SWIG_IsOK(res1)) {
33148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33149 }
33150 arg1 = reinterpret_cast< wxWindow * >(argp1);
33151 ecode2 = SWIG_AsVal_long(obj1, &val2);
33152 if (!SWIG_IsOK(ecode2)) {
33153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33154 }
33155 arg2 = static_cast< long >(val2);
33156 {
33157 PyThreadState* __tstate = wxPyBeginAllowThreads();
33158 (arg1)->SetExtraStyle(arg2);
33159 wxPyEndAllowThreads(__tstate);
33160 if (PyErr_Occurred()) SWIG_fail;
33161 }
33162 resultobj = SWIG_Py_Void();
33163 return resultobj;
33164 fail:
33165 return NULL;
33166 }
33167
33168
33169 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33170 PyObject *resultobj = 0;
33171 wxWindow *arg1 = (wxWindow *) 0 ;
33172 long result;
33173 void *argp1 = 0 ;
33174 int res1 = 0 ;
33175 PyObject *swig_obj[1] ;
33176
33177 if (!args) SWIG_fail;
33178 swig_obj[0] = args;
33179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33180 if (!SWIG_IsOK(res1)) {
33181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33182 }
33183 arg1 = reinterpret_cast< wxWindow * >(argp1);
33184 {
33185 PyThreadState* __tstate = wxPyBeginAllowThreads();
33186 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33187 wxPyEndAllowThreads(__tstate);
33188 if (PyErr_Occurred()) SWIG_fail;
33189 }
33190 resultobj = SWIG_From_long(static_cast< long >(result));
33191 return resultobj;
33192 fail:
33193 return NULL;
33194 }
33195
33196
33197 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33198 PyObject *resultobj = 0;
33199 wxWindow *arg1 = (wxWindow *) 0 ;
33200 bool arg2 = (bool) true ;
33201 void *argp1 = 0 ;
33202 int res1 = 0 ;
33203 bool val2 ;
33204 int ecode2 = 0 ;
33205 PyObject * obj0 = 0 ;
33206 PyObject * obj1 = 0 ;
33207 char * kwnames[] = {
33208 (char *) "self",(char *) "modal", NULL
33209 };
33210
33211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33213 if (!SWIG_IsOK(res1)) {
33214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33215 }
33216 arg1 = reinterpret_cast< wxWindow * >(argp1);
33217 if (obj1) {
33218 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33219 if (!SWIG_IsOK(ecode2)) {
33220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33221 }
33222 arg2 = static_cast< bool >(val2);
33223 }
33224 {
33225 PyThreadState* __tstate = wxPyBeginAllowThreads();
33226 (arg1)->MakeModal(arg2);
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 resultobj = SWIG_Py_Void();
33231 return resultobj;
33232 fail:
33233 return NULL;
33234 }
33235
33236
33237 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33238 PyObject *resultobj = 0;
33239 wxWindow *arg1 = (wxWindow *) 0 ;
33240 bool arg2 ;
33241 void *argp1 = 0 ;
33242 int res1 = 0 ;
33243 bool val2 ;
33244 int ecode2 = 0 ;
33245 PyObject * obj0 = 0 ;
33246 PyObject * obj1 = 0 ;
33247 char * kwnames[] = {
33248 (char *) "self",(char *) "enableTheme", NULL
33249 };
33250
33251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33253 if (!SWIG_IsOK(res1)) {
33254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33255 }
33256 arg1 = reinterpret_cast< wxWindow * >(argp1);
33257 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33258 if (!SWIG_IsOK(ecode2)) {
33259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33260 }
33261 arg2 = static_cast< bool >(val2);
33262 {
33263 PyThreadState* __tstate = wxPyBeginAllowThreads();
33264 (arg1)->SetThemeEnabled(arg2);
33265 wxPyEndAllowThreads(__tstate);
33266 if (PyErr_Occurred()) SWIG_fail;
33267 }
33268 resultobj = SWIG_Py_Void();
33269 return resultobj;
33270 fail:
33271 return NULL;
33272 }
33273
33274
33275 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33276 PyObject *resultobj = 0;
33277 wxWindow *arg1 = (wxWindow *) 0 ;
33278 bool result;
33279 void *argp1 = 0 ;
33280 int res1 = 0 ;
33281 PyObject *swig_obj[1] ;
33282
33283 if (!args) SWIG_fail;
33284 swig_obj[0] = args;
33285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33286 if (!SWIG_IsOK(res1)) {
33287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33288 }
33289 arg1 = reinterpret_cast< wxWindow * >(argp1);
33290 {
33291 PyThreadState* __tstate = wxPyBeginAllowThreads();
33292 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33293 wxPyEndAllowThreads(__tstate);
33294 if (PyErr_Occurred()) SWIG_fail;
33295 }
33296 {
33297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33298 }
33299 return resultobj;
33300 fail:
33301 return NULL;
33302 }
33303
33304
33305 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33306 PyObject *resultobj = 0;
33307 wxWindow *arg1 = (wxWindow *) 0 ;
33308 void *argp1 = 0 ;
33309 int res1 = 0 ;
33310 PyObject *swig_obj[1] ;
33311
33312 if (!args) SWIG_fail;
33313 swig_obj[0] = args;
33314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33315 if (!SWIG_IsOK(res1)) {
33316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33317 }
33318 arg1 = reinterpret_cast< wxWindow * >(argp1);
33319 {
33320 PyThreadState* __tstate = wxPyBeginAllowThreads();
33321 (arg1)->SetFocus();
33322 wxPyEndAllowThreads(__tstate);
33323 if (PyErr_Occurred()) SWIG_fail;
33324 }
33325 resultobj = SWIG_Py_Void();
33326 return resultobj;
33327 fail:
33328 return NULL;
33329 }
33330
33331
33332 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33333 PyObject *resultobj = 0;
33334 wxWindow *arg1 = (wxWindow *) 0 ;
33335 void *argp1 = 0 ;
33336 int res1 = 0 ;
33337 PyObject *swig_obj[1] ;
33338
33339 if (!args) SWIG_fail;
33340 swig_obj[0] = args;
33341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33342 if (!SWIG_IsOK(res1)) {
33343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33344 }
33345 arg1 = reinterpret_cast< wxWindow * >(argp1);
33346 {
33347 PyThreadState* __tstate = wxPyBeginAllowThreads();
33348 (arg1)->SetFocusFromKbd();
33349 wxPyEndAllowThreads(__tstate);
33350 if (PyErr_Occurred()) SWIG_fail;
33351 }
33352 resultobj = SWIG_Py_Void();
33353 return resultobj;
33354 fail:
33355 return NULL;
33356 }
33357
33358
33359 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33360 PyObject *resultobj = 0;
33361 wxWindow *result = 0 ;
33362
33363 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33364 {
33365 if (!wxPyCheckForApp()) SWIG_fail;
33366 PyThreadState* __tstate = wxPyBeginAllowThreads();
33367 result = (wxWindow *)wxWindow::FindFocus();
33368 wxPyEndAllowThreads(__tstate);
33369 if (PyErr_Occurred()) SWIG_fail;
33370 }
33371 {
33372 resultobj = wxPyMake_wxObject(result, 0);
33373 }
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33381 PyObject *resultobj = 0;
33382 wxWindow *arg1 = (wxWindow *) 0 ;
33383 bool result;
33384 void *argp1 = 0 ;
33385 int res1 = 0 ;
33386 PyObject *swig_obj[1] ;
33387
33388 if (!args) SWIG_fail;
33389 swig_obj[0] = args;
33390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33391 if (!SWIG_IsOK(res1)) {
33392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33393 }
33394 arg1 = reinterpret_cast< wxWindow * >(argp1);
33395 {
33396 PyThreadState* __tstate = wxPyBeginAllowThreads();
33397 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 {
33402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33403 }
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33411 PyObject *resultobj = 0;
33412 wxWindow *arg1 = (wxWindow *) 0 ;
33413 bool result;
33414 void *argp1 = 0 ;
33415 int res1 = 0 ;
33416 PyObject *swig_obj[1] ;
33417
33418 if (!args) SWIG_fail;
33419 swig_obj[0] = args;
33420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33421 if (!SWIG_IsOK(res1)) {
33422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33423 }
33424 arg1 = reinterpret_cast< wxWindow * >(argp1);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 {
33432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33433 }
33434 return resultobj;
33435 fail:
33436 return NULL;
33437 }
33438
33439
33440 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33441 PyObject *resultobj = 0;
33442 wxWindow *arg1 = (wxWindow *) 0 ;
33443 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33444 bool result;
33445 void *argp1 = 0 ;
33446 int res1 = 0 ;
33447 int val2 ;
33448 int ecode2 = 0 ;
33449 PyObject * obj0 = 0 ;
33450 PyObject * obj1 = 0 ;
33451 char * kwnames[] = {
33452 (char *) "self",(char *) "flags", NULL
33453 };
33454
33455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33457 if (!SWIG_IsOK(res1)) {
33458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33459 }
33460 arg1 = reinterpret_cast< wxWindow * >(argp1);
33461 if (obj1) {
33462 ecode2 = SWIG_AsVal_int(obj1, &val2);
33463 if (!SWIG_IsOK(ecode2)) {
33464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33465 }
33466 arg2 = static_cast< int >(val2);
33467 }
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 result = (bool)(arg1)->Navigate(arg2);
33471 wxPyEndAllowThreads(__tstate);
33472 if (PyErr_Occurred()) SWIG_fail;
33473 }
33474 {
33475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33476 }
33477 return resultobj;
33478 fail:
33479 return NULL;
33480 }
33481
33482
33483 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33484 PyObject *resultobj = 0;
33485 wxWindow *arg1 = (wxWindow *) 0 ;
33486 wxWindow *arg2 = (wxWindow *) 0 ;
33487 void *argp1 = 0 ;
33488 int res1 = 0 ;
33489 void *argp2 = 0 ;
33490 int res2 = 0 ;
33491 PyObject * obj0 = 0 ;
33492 PyObject * obj1 = 0 ;
33493 char * kwnames[] = {
33494 (char *) "self",(char *) "win", NULL
33495 };
33496
33497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33499 if (!SWIG_IsOK(res1)) {
33500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33501 }
33502 arg1 = reinterpret_cast< wxWindow * >(argp1);
33503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33504 if (!SWIG_IsOK(res2)) {
33505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33506 }
33507 arg2 = reinterpret_cast< wxWindow * >(argp2);
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 (arg1)->MoveAfterInTabOrder(arg2);
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 resultobj = SWIG_Py_Void();
33515 return resultobj;
33516 fail:
33517 return NULL;
33518 }
33519
33520
33521 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33522 PyObject *resultobj = 0;
33523 wxWindow *arg1 = (wxWindow *) 0 ;
33524 wxWindow *arg2 = (wxWindow *) 0 ;
33525 void *argp1 = 0 ;
33526 int res1 = 0 ;
33527 void *argp2 = 0 ;
33528 int res2 = 0 ;
33529 PyObject * obj0 = 0 ;
33530 PyObject * obj1 = 0 ;
33531 char * kwnames[] = {
33532 (char *) "self",(char *) "win", NULL
33533 };
33534
33535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33537 if (!SWIG_IsOK(res1)) {
33538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33539 }
33540 arg1 = reinterpret_cast< wxWindow * >(argp1);
33541 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33542 if (!SWIG_IsOK(res2)) {
33543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33544 }
33545 arg2 = reinterpret_cast< wxWindow * >(argp2);
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 (arg1)->MoveBeforeInTabOrder(arg2);
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 resultobj = SWIG_Py_Void();
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33560 PyObject *resultobj = 0;
33561 wxWindow *arg1 = (wxWindow *) 0 ;
33562 PyObject *result = 0 ;
33563 void *argp1 = 0 ;
33564 int res1 = 0 ;
33565 PyObject *swig_obj[1] ;
33566
33567 if (!args) SWIG_fail;
33568 swig_obj[0] = args;
33569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33570 if (!SWIG_IsOK(res1)) {
33571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33572 }
33573 arg1 = reinterpret_cast< wxWindow * >(argp1);
33574 {
33575 PyThreadState* __tstate = wxPyBeginAllowThreads();
33576 result = (PyObject *)wxWindow_GetChildren(arg1);
33577 wxPyEndAllowThreads(__tstate);
33578 if (PyErr_Occurred()) SWIG_fail;
33579 }
33580 resultobj = result;
33581 return resultobj;
33582 fail:
33583 return NULL;
33584 }
33585
33586
33587 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33588 PyObject *resultobj = 0;
33589 wxWindow *arg1 = (wxWindow *) 0 ;
33590 wxWindow *result = 0 ;
33591 void *argp1 = 0 ;
33592 int res1 = 0 ;
33593 PyObject *swig_obj[1] ;
33594
33595 if (!args) SWIG_fail;
33596 swig_obj[0] = args;
33597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33598 if (!SWIG_IsOK(res1)) {
33599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33600 }
33601 arg1 = reinterpret_cast< wxWindow * >(argp1);
33602 {
33603 PyThreadState* __tstate = wxPyBeginAllowThreads();
33604 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33605 wxPyEndAllowThreads(__tstate);
33606 if (PyErr_Occurred()) SWIG_fail;
33607 }
33608 {
33609 resultobj = wxPyMake_wxObject(result, 0);
33610 }
33611 return resultobj;
33612 fail:
33613 return NULL;
33614 }
33615
33616
33617 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33618 PyObject *resultobj = 0;
33619 wxWindow *arg1 = (wxWindow *) 0 ;
33620 wxWindow *result = 0 ;
33621 void *argp1 = 0 ;
33622 int res1 = 0 ;
33623 PyObject *swig_obj[1] ;
33624
33625 if (!args) SWIG_fail;
33626 swig_obj[0] = args;
33627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33628 if (!SWIG_IsOK(res1)) {
33629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33630 }
33631 arg1 = reinterpret_cast< wxWindow * >(argp1);
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 {
33639 resultobj = wxPyMake_wxObject(result, 0);
33640 }
33641 return resultobj;
33642 fail:
33643 return NULL;
33644 }
33645
33646
33647 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33648 PyObject *resultobj = 0;
33649 wxWindow *arg1 = (wxWindow *) 0 ;
33650 bool result;
33651 void *argp1 = 0 ;
33652 int res1 = 0 ;
33653 PyObject *swig_obj[1] ;
33654
33655 if (!args) SWIG_fail;
33656 swig_obj[0] = args;
33657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33658 if (!SWIG_IsOK(res1)) {
33659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33660 }
33661 arg1 = reinterpret_cast< wxWindow * >(argp1);
33662 {
33663 PyThreadState* __tstate = wxPyBeginAllowThreads();
33664 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33665 wxPyEndAllowThreads(__tstate);
33666 if (PyErr_Occurred()) SWIG_fail;
33667 }
33668 {
33669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33670 }
33671 return resultobj;
33672 fail:
33673 return NULL;
33674 }
33675
33676
33677 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33678 PyObject *resultobj = 0;
33679 wxWindow *arg1 = (wxWindow *) 0 ;
33680 wxWindow *arg2 = (wxWindow *) 0 ;
33681 bool result;
33682 void *argp1 = 0 ;
33683 int res1 = 0 ;
33684 void *argp2 = 0 ;
33685 int res2 = 0 ;
33686 PyObject * obj0 = 0 ;
33687 PyObject * obj1 = 0 ;
33688 char * kwnames[] = {
33689 (char *) "self",(char *) "newParent", NULL
33690 };
33691
33692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33694 if (!SWIG_IsOK(res1)) {
33695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33696 }
33697 arg1 = reinterpret_cast< wxWindow * >(argp1);
33698 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33699 if (!SWIG_IsOK(res2)) {
33700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33701 }
33702 arg2 = reinterpret_cast< wxWindow * >(argp2);
33703 {
33704 PyThreadState* __tstate = wxPyBeginAllowThreads();
33705 result = (bool)(arg1)->Reparent(arg2);
33706 wxPyEndAllowThreads(__tstate);
33707 if (PyErr_Occurred()) SWIG_fail;
33708 }
33709 {
33710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33711 }
33712 return resultobj;
33713 fail:
33714 return NULL;
33715 }
33716
33717
33718 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33719 PyObject *resultobj = 0;
33720 wxWindow *arg1 = (wxWindow *) 0 ;
33721 wxWindow *arg2 = (wxWindow *) 0 ;
33722 void *argp1 = 0 ;
33723 int res1 = 0 ;
33724 void *argp2 = 0 ;
33725 int res2 = 0 ;
33726 PyObject * obj0 = 0 ;
33727 PyObject * obj1 = 0 ;
33728 char * kwnames[] = {
33729 (char *) "self",(char *) "child", NULL
33730 };
33731
33732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33734 if (!SWIG_IsOK(res1)) {
33735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33736 }
33737 arg1 = reinterpret_cast< wxWindow * >(argp1);
33738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33739 if (!SWIG_IsOK(res2)) {
33740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33741 }
33742 arg2 = reinterpret_cast< wxWindow * >(argp2);
33743 {
33744 PyThreadState* __tstate = wxPyBeginAllowThreads();
33745 (arg1)->AddChild(arg2);
33746 wxPyEndAllowThreads(__tstate);
33747 if (PyErr_Occurred()) SWIG_fail;
33748 }
33749 resultobj = SWIG_Py_Void();
33750 return resultobj;
33751 fail:
33752 return NULL;
33753 }
33754
33755
33756 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33757 PyObject *resultobj = 0;
33758 wxWindow *arg1 = (wxWindow *) 0 ;
33759 wxWindow *arg2 = (wxWindow *) 0 ;
33760 void *argp1 = 0 ;
33761 int res1 = 0 ;
33762 void *argp2 = 0 ;
33763 int res2 = 0 ;
33764 PyObject * obj0 = 0 ;
33765 PyObject * obj1 = 0 ;
33766 char * kwnames[] = {
33767 (char *) "self",(char *) "child", NULL
33768 };
33769
33770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33772 if (!SWIG_IsOK(res1)) {
33773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33774 }
33775 arg1 = reinterpret_cast< wxWindow * >(argp1);
33776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33777 if (!SWIG_IsOK(res2)) {
33778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33779 }
33780 arg2 = reinterpret_cast< wxWindow * >(argp2);
33781 {
33782 PyThreadState* __tstate = wxPyBeginAllowThreads();
33783 (arg1)->RemoveChild(arg2);
33784 wxPyEndAllowThreads(__tstate);
33785 if (PyErr_Occurred()) SWIG_fail;
33786 }
33787 resultobj = SWIG_Py_Void();
33788 return resultobj;
33789 fail:
33790 return NULL;
33791 }
33792
33793
33794 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33795 PyObject *resultobj = 0;
33796 wxWindow *arg1 = (wxWindow *) 0 ;
33797 bool arg2 ;
33798 void *argp1 = 0 ;
33799 int res1 = 0 ;
33800 bool val2 ;
33801 int ecode2 = 0 ;
33802 PyObject * obj0 = 0 ;
33803 PyObject * obj1 = 0 ;
33804 char * kwnames[] = {
33805 (char *) "self",(char *) "on", NULL
33806 };
33807
33808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33810 if (!SWIG_IsOK(res1)) {
33811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33812 }
33813 arg1 = reinterpret_cast< wxWindow * >(argp1);
33814 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33815 if (!SWIG_IsOK(ecode2)) {
33816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33817 }
33818 arg2 = static_cast< bool >(val2);
33819 {
33820 PyThreadState* __tstate = wxPyBeginAllowThreads();
33821 wxWindow_SetDoubleBuffered(arg1,arg2);
33822 wxPyEndAllowThreads(__tstate);
33823 if (PyErr_Occurred()) SWIG_fail;
33824 }
33825 resultobj = SWIG_Py_Void();
33826 return resultobj;
33827 fail:
33828 return NULL;
33829 }
33830
33831
33832 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33833 PyObject *resultobj = 0;
33834 wxWindow *arg1 = (wxWindow *) 0 ;
33835 long arg2 ;
33836 wxWindow *result = 0 ;
33837 void *argp1 = 0 ;
33838 int res1 = 0 ;
33839 long val2 ;
33840 int ecode2 = 0 ;
33841 PyObject * obj0 = 0 ;
33842 PyObject * obj1 = 0 ;
33843 char * kwnames[] = {
33844 (char *) "self",(char *) "winid", NULL
33845 };
33846
33847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33849 if (!SWIG_IsOK(res1)) {
33850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33851 }
33852 arg1 = reinterpret_cast< wxWindow * >(argp1);
33853 ecode2 = SWIG_AsVal_long(obj1, &val2);
33854 if (!SWIG_IsOK(ecode2)) {
33855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33856 }
33857 arg2 = static_cast< long >(val2);
33858 {
33859 PyThreadState* __tstate = wxPyBeginAllowThreads();
33860 result = (wxWindow *)(arg1)->FindWindow(arg2);
33861 wxPyEndAllowThreads(__tstate);
33862 if (PyErr_Occurred()) SWIG_fail;
33863 }
33864 {
33865 resultobj = wxPyMake_wxObject(result, 0);
33866 }
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 wxString *arg2 = 0 ;
33877 wxWindow *result = 0 ;
33878 void *argp1 = 0 ;
33879 int res1 = 0 ;
33880 bool temp2 = false ;
33881 PyObject * obj0 = 0 ;
33882 PyObject * obj1 = 0 ;
33883 char * kwnames[] = {
33884 (char *) "self",(char *) "name", NULL
33885 };
33886
33887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33889 if (!SWIG_IsOK(res1)) {
33890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33891 }
33892 arg1 = reinterpret_cast< wxWindow * >(argp1);
33893 {
33894 arg2 = wxString_in_helper(obj1);
33895 if (arg2 == NULL) SWIG_fail;
33896 temp2 = true;
33897 }
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = wxPyMake_wxObject(result, 0);
33906 }
33907 {
33908 if (temp2)
33909 delete arg2;
33910 }
33911 return resultobj;
33912 fail:
33913 {
33914 if (temp2)
33915 delete arg2;
33916 }
33917 return NULL;
33918 }
33919
33920
33921 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33922 PyObject *resultobj = 0;
33923 wxWindow *arg1 = (wxWindow *) 0 ;
33924 wxEvtHandler *result = 0 ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 PyObject *swig_obj[1] ;
33928
33929 if (!args) SWIG_fail;
33930 swig_obj[0] = args;
33931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33932 if (!SWIG_IsOK(res1)) {
33933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33934 }
33935 arg1 = reinterpret_cast< wxWindow * >(argp1);
33936 {
33937 PyThreadState* __tstate = wxPyBeginAllowThreads();
33938 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33939 wxPyEndAllowThreads(__tstate);
33940 if (PyErr_Occurred()) SWIG_fail;
33941 }
33942 {
33943 resultobj = wxPyMake_wxObject(result, 0);
33944 }
33945 return resultobj;
33946 fail:
33947 return NULL;
33948 }
33949
33950
33951 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33952 PyObject *resultobj = 0;
33953 wxWindow *arg1 = (wxWindow *) 0 ;
33954 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33955 void *argp1 = 0 ;
33956 int res1 = 0 ;
33957 void *argp2 = 0 ;
33958 int res2 = 0 ;
33959 PyObject * obj0 = 0 ;
33960 PyObject * obj1 = 0 ;
33961 char * kwnames[] = {
33962 (char *) "self",(char *) "handler", NULL
33963 };
33964
33965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33967 if (!SWIG_IsOK(res1)) {
33968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33969 }
33970 arg1 = reinterpret_cast< wxWindow * >(argp1);
33971 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33972 if (!SWIG_IsOK(res2)) {
33973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33974 }
33975 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33976 {
33977 PyThreadState* __tstate = wxPyBeginAllowThreads();
33978 (arg1)->SetEventHandler(arg2);
33979 wxPyEndAllowThreads(__tstate);
33980 if (PyErr_Occurred()) SWIG_fail;
33981 }
33982 resultobj = SWIG_Py_Void();
33983 return resultobj;
33984 fail:
33985 return NULL;
33986 }
33987
33988
33989 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33990 PyObject *resultobj = 0;
33991 wxWindow *arg1 = (wxWindow *) 0 ;
33992 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33993 void *argp1 = 0 ;
33994 int res1 = 0 ;
33995 void *argp2 = 0 ;
33996 int res2 = 0 ;
33997 PyObject * obj0 = 0 ;
33998 PyObject * obj1 = 0 ;
33999 char * kwnames[] = {
34000 (char *) "self",(char *) "handler", NULL
34001 };
34002
34003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34005 if (!SWIG_IsOK(res1)) {
34006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34007 }
34008 arg1 = reinterpret_cast< wxWindow * >(argp1);
34009 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34010 if (!SWIG_IsOK(res2)) {
34011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34012 }
34013 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34014 {
34015 PyThreadState* __tstate = wxPyBeginAllowThreads();
34016 (arg1)->PushEventHandler(arg2);
34017 wxPyEndAllowThreads(__tstate);
34018 if (PyErr_Occurred()) SWIG_fail;
34019 }
34020 resultobj = SWIG_Py_Void();
34021 return resultobj;
34022 fail:
34023 return NULL;
34024 }
34025
34026
34027 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34028 PyObject *resultobj = 0;
34029 wxWindow *arg1 = (wxWindow *) 0 ;
34030 bool arg2 = (bool) false ;
34031 wxEvtHandler *result = 0 ;
34032 void *argp1 = 0 ;
34033 int res1 = 0 ;
34034 bool val2 ;
34035 int ecode2 = 0 ;
34036 PyObject * obj0 = 0 ;
34037 PyObject * obj1 = 0 ;
34038 char * kwnames[] = {
34039 (char *) "self",(char *) "deleteHandler", NULL
34040 };
34041
34042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34044 if (!SWIG_IsOK(res1)) {
34045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34046 }
34047 arg1 = reinterpret_cast< wxWindow * >(argp1);
34048 if (obj1) {
34049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34050 if (!SWIG_IsOK(ecode2)) {
34051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34052 }
34053 arg2 = static_cast< bool >(val2);
34054 }
34055 {
34056 PyThreadState* __tstate = wxPyBeginAllowThreads();
34057 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 {
34062 resultobj = wxPyMake_wxObject(result, 0);
34063 }
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj = 0;
34072 wxWindow *arg1 = (wxWindow *) 0 ;
34073 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34074 bool result;
34075 void *argp1 = 0 ;
34076 int res1 = 0 ;
34077 void *argp2 = 0 ;
34078 int res2 = 0 ;
34079 PyObject * obj0 = 0 ;
34080 PyObject * obj1 = 0 ;
34081 char * kwnames[] = {
34082 (char *) "self",(char *) "handler", NULL
34083 };
34084
34085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34087 if (!SWIG_IsOK(res1)) {
34088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34089 }
34090 arg1 = reinterpret_cast< wxWindow * >(argp1);
34091 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34092 if (!SWIG_IsOK(res2)) {
34093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34094 }
34095 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 result = (bool)(arg1)->RemoveEventHandler(arg2);
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 {
34103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34104 }
34105 return resultobj;
34106 fail:
34107 return NULL;
34108 }
34109
34110
34111 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34112 PyObject *resultobj = 0;
34113 wxWindow *arg1 = (wxWindow *) 0 ;
34114 wxValidator *arg2 = 0 ;
34115 void *argp1 = 0 ;
34116 int res1 = 0 ;
34117 void *argp2 = 0 ;
34118 int res2 = 0 ;
34119 PyObject * obj0 = 0 ;
34120 PyObject * obj1 = 0 ;
34121 char * kwnames[] = {
34122 (char *) "self",(char *) "validator", NULL
34123 };
34124
34125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34127 if (!SWIG_IsOK(res1)) {
34128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34129 }
34130 arg1 = reinterpret_cast< wxWindow * >(argp1);
34131 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34132 if (!SWIG_IsOK(res2)) {
34133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34134 }
34135 if (!argp2) {
34136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34137 }
34138 arg2 = reinterpret_cast< wxValidator * >(argp2);
34139 {
34140 PyThreadState* __tstate = wxPyBeginAllowThreads();
34141 (arg1)->SetValidator((wxValidator const &)*arg2);
34142 wxPyEndAllowThreads(__tstate);
34143 if (PyErr_Occurred()) SWIG_fail;
34144 }
34145 resultobj = SWIG_Py_Void();
34146 return resultobj;
34147 fail:
34148 return NULL;
34149 }
34150
34151
34152 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34153 PyObject *resultobj = 0;
34154 wxWindow *arg1 = (wxWindow *) 0 ;
34155 wxValidator *result = 0 ;
34156 void *argp1 = 0 ;
34157 int res1 = 0 ;
34158 PyObject *swig_obj[1] ;
34159
34160 if (!args) SWIG_fail;
34161 swig_obj[0] = args;
34162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34163 if (!SWIG_IsOK(res1)) {
34164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34165 }
34166 arg1 = reinterpret_cast< wxWindow * >(argp1);
34167 {
34168 PyThreadState* __tstate = wxPyBeginAllowThreads();
34169 result = (wxValidator *)(arg1)->GetValidator();
34170 wxPyEndAllowThreads(__tstate);
34171 if (PyErr_Occurred()) SWIG_fail;
34172 }
34173 {
34174 resultobj = wxPyMake_wxObject(result, (bool)0);
34175 }
34176 return resultobj;
34177 fail:
34178 return NULL;
34179 }
34180
34181
34182 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34183 PyObject *resultobj = 0;
34184 wxWindow *arg1 = (wxWindow *) 0 ;
34185 bool result;
34186 void *argp1 = 0 ;
34187 int res1 = 0 ;
34188 PyObject *swig_obj[1] ;
34189
34190 if (!args) SWIG_fail;
34191 swig_obj[0] = args;
34192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34193 if (!SWIG_IsOK(res1)) {
34194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34195 }
34196 arg1 = reinterpret_cast< wxWindow * >(argp1);
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 result = (bool)(arg1)->Validate();
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 {
34204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34205 }
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34213 PyObject *resultobj = 0;
34214 wxWindow *arg1 = (wxWindow *) 0 ;
34215 bool result;
34216 void *argp1 = 0 ;
34217 int res1 = 0 ;
34218 PyObject *swig_obj[1] ;
34219
34220 if (!args) SWIG_fail;
34221 swig_obj[0] = args;
34222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34223 if (!SWIG_IsOK(res1)) {
34224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34225 }
34226 arg1 = reinterpret_cast< wxWindow * >(argp1);
34227 {
34228 PyThreadState* __tstate = wxPyBeginAllowThreads();
34229 result = (bool)(arg1)->TransferDataToWindow();
34230 wxPyEndAllowThreads(__tstate);
34231 if (PyErr_Occurred()) SWIG_fail;
34232 }
34233 {
34234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34235 }
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34243 PyObject *resultobj = 0;
34244 wxWindow *arg1 = (wxWindow *) 0 ;
34245 bool result;
34246 void *argp1 = 0 ;
34247 int res1 = 0 ;
34248 PyObject *swig_obj[1] ;
34249
34250 if (!args) SWIG_fail;
34251 swig_obj[0] = args;
34252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34253 if (!SWIG_IsOK(res1)) {
34254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34255 }
34256 arg1 = reinterpret_cast< wxWindow * >(argp1);
34257 {
34258 PyThreadState* __tstate = wxPyBeginAllowThreads();
34259 result = (bool)(arg1)->TransferDataFromWindow();
34260 wxPyEndAllowThreads(__tstate);
34261 if (PyErr_Occurred()) SWIG_fail;
34262 }
34263 {
34264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34265 }
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34273 PyObject *resultobj = 0;
34274 wxWindow *arg1 = (wxWindow *) 0 ;
34275 void *argp1 = 0 ;
34276 int res1 = 0 ;
34277 PyObject *swig_obj[1] ;
34278
34279 if (!args) SWIG_fail;
34280 swig_obj[0] = args;
34281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34282 if (!SWIG_IsOK(res1)) {
34283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34284 }
34285 arg1 = reinterpret_cast< wxWindow * >(argp1);
34286 {
34287 PyThreadState* __tstate = wxPyBeginAllowThreads();
34288 (arg1)->InitDialog();
34289 wxPyEndAllowThreads(__tstate);
34290 if (PyErr_Occurred()) SWIG_fail;
34291 }
34292 resultobj = SWIG_Py_Void();
34293 return resultobj;
34294 fail:
34295 return NULL;
34296 }
34297
34298
34299 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34300 PyObject *resultobj = 0;
34301 wxWindow *arg1 = (wxWindow *) 0 ;
34302 wxAcceleratorTable *arg2 = 0 ;
34303 void *argp1 = 0 ;
34304 int res1 = 0 ;
34305 void *argp2 = 0 ;
34306 int res2 = 0 ;
34307 PyObject * obj0 = 0 ;
34308 PyObject * obj1 = 0 ;
34309 char * kwnames[] = {
34310 (char *) "self",(char *) "accel", NULL
34311 };
34312
34313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34315 if (!SWIG_IsOK(res1)) {
34316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34317 }
34318 arg1 = reinterpret_cast< wxWindow * >(argp1);
34319 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34320 if (!SWIG_IsOK(res2)) {
34321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34322 }
34323 if (!argp2) {
34324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34325 }
34326 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 resultobj = SWIG_Py_Void();
34334 return resultobj;
34335 fail:
34336 return NULL;
34337 }
34338
34339
34340 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34341 PyObject *resultobj = 0;
34342 wxWindow *arg1 = (wxWindow *) 0 ;
34343 wxAcceleratorTable *result = 0 ;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 PyObject *swig_obj[1] ;
34347
34348 if (!args) SWIG_fail;
34349 swig_obj[0] = args;
34350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34351 if (!SWIG_IsOK(res1)) {
34352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34353 }
34354 arg1 = reinterpret_cast< wxWindow * >(argp1);
34355 {
34356 PyThreadState* __tstate = wxPyBeginAllowThreads();
34357 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34358 wxPyEndAllowThreads(__tstate);
34359 if (PyErr_Occurred()) SWIG_fail;
34360 }
34361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34362 return resultobj;
34363 fail:
34364 return NULL;
34365 }
34366
34367
34368 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34369 PyObject *resultobj = 0;
34370 wxWindow *arg1 = (wxWindow *) 0 ;
34371 int arg2 ;
34372 int arg3 ;
34373 int arg4 ;
34374 bool result;
34375 void *argp1 = 0 ;
34376 int res1 = 0 ;
34377 int val2 ;
34378 int ecode2 = 0 ;
34379 int val3 ;
34380 int ecode3 = 0 ;
34381 int val4 ;
34382 int ecode4 = 0 ;
34383 PyObject * obj0 = 0 ;
34384 PyObject * obj1 = 0 ;
34385 PyObject * obj2 = 0 ;
34386 PyObject * obj3 = 0 ;
34387 char * kwnames[] = {
34388 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34389 };
34390
34391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34393 if (!SWIG_IsOK(res1)) {
34394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34395 }
34396 arg1 = reinterpret_cast< wxWindow * >(argp1);
34397 ecode2 = SWIG_AsVal_int(obj1, &val2);
34398 if (!SWIG_IsOK(ecode2)) {
34399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34400 }
34401 arg2 = static_cast< int >(val2);
34402 ecode3 = SWIG_AsVal_int(obj2, &val3);
34403 if (!SWIG_IsOK(ecode3)) {
34404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34405 }
34406 arg3 = static_cast< int >(val3);
34407 ecode4 = SWIG_AsVal_int(obj3, &val4);
34408 if (!SWIG_IsOK(ecode4)) {
34409 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34410 }
34411 arg4 = static_cast< int >(val4);
34412 {
34413 PyThreadState* __tstate = wxPyBeginAllowThreads();
34414 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34415 wxPyEndAllowThreads(__tstate);
34416 if (PyErr_Occurred()) SWIG_fail;
34417 }
34418 {
34419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34420 }
34421 return resultobj;
34422 fail:
34423 return NULL;
34424 }
34425
34426
34427 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34428 PyObject *resultobj = 0;
34429 wxWindow *arg1 = (wxWindow *) 0 ;
34430 int arg2 ;
34431 bool result;
34432 void *argp1 = 0 ;
34433 int res1 = 0 ;
34434 int val2 ;
34435 int ecode2 = 0 ;
34436 PyObject * obj0 = 0 ;
34437 PyObject * obj1 = 0 ;
34438 char * kwnames[] = {
34439 (char *) "self",(char *) "hotkeyId", NULL
34440 };
34441
34442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34444 if (!SWIG_IsOK(res1)) {
34445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34446 }
34447 arg1 = reinterpret_cast< wxWindow * >(argp1);
34448 ecode2 = SWIG_AsVal_int(obj1, &val2);
34449 if (!SWIG_IsOK(ecode2)) {
34450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34451 }
34452 arg2 = static_cast< int >(val2);
34453 {
34454 PyThreadState* __tstate = wxPyBeginAllowThreads();
34455 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34456 wxPyEndAllowThreads(__tstate);
34457 if (PyErr_Occurred()) SWIG_fail;
34458 }
34459 {
34460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34461 }
34462 return resultobj;
34463 fail:
34464 return NULL;
34465 }
34466
34467
34468 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34469 PyObject *resultobj = 0;
34470 wxWindow *arg1 = (wxWindow *) 0 ;
34471 wxPoint *arg2 = 0 ;
34472 wxPoint result;
34473 void *argp1 = 0 ;
34474 int res1 = 0 ;
34475 wxPoint temp2 ;
34476 PyObject * obj0 = 0 ;
34477 PyObject * obj1 = 0 ;
34478 char * kwnames[] = {
34479 (char *) "self",(char *) "pt", NULL
34480 };
34481
34482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34484 if (!SWIG_IsOK(res1)) {
34485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34486 }
34487 arg1 = reinterpret_cast< wxWindow * >(argp1);
34488 {
34489 arg2 = &temp2;
34490 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34491 }
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34499 return resultobj;
34500 fail:
34501 return NULL;
34502 }
34503
34504
34505 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34506 PyObject *resultobj = 0;
34507 wxWindow *arg1 = (wxWindow *) 0 ;
34508 wxSize *arg2 = 0 ;
34509 wxSize result;
34510 void *argp1 = 0 ;
34511 int res1 = 0 ;
34512 wxSize temp2 ;
34513 PyObject * obj0 = 0 ;
34514 PyObject * obj1 = 0 ;
34515 char * kwnames[] = {
34516 (char *) "self",(char *) "sz", NULL
34517 };
34518
34519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34521 if (!SWIG_IsOK(res1)) {
34522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34523 }
34524 arg1 = reinterpret_cast< wxWindow * >(argp1);
34525 {
34526 arg2 = &temp2;
34527 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34528 }
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34543 PyObject *resultobj = 0;
34544 wxWindow *arg1 = (wxWindow *) 0 ;
34545 wxPoint *arg2 = 0 ;
34546 wxPoint result;
34547 void *argp1 = 0 ;
34548 int res1 = 0 ;
34549 wxPoint temp2 ;
34550 PyObject * obj0 = 0 ;
34551 PyObject * obj1 = 0 ;
34552 char * kwnames[] = {
34553 (char *) "self",(char *) "pt", NULL
34554 };
34555
34556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34558 if (!SWIG_IsOK(res1)) {
34559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34560 }
34561 arg1 = reinterpret_cast< wxWindow * >(argp1);
34562 {
34563 arg2 = &temp2;
34564 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34565 }
34566 {
34567 PyThreadState* __tstate = wxPyBeginAllowThreads();
34568 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34569 wxPyEndAllowThreads(__tstate);
34570 if (PyErr_Occurred()) SWIG_fail;
34571 }
34572 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34573 return resultobj;
34574 fail:
34575 return NULL;
34576 }
34577
34578
34579 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34580 PyObject *resultobj = 0;
34581 wxWindow *arg1 = (wxWindow *) 0 ;
34582 wxSize *arg2 = 0 ;
34583 wxSize result;
34584 void *argp1 = 0 ;
34585 int res1 = 0 ;
34586 wxSize temp2 ;
34587 PyObject * obj0 = 0 ;
34588 PyObject * obj1 = 0 ;
34589 char * kwnames[] = {
34590 (char *) "self",(char *) "sz", NULL
34591 };
34592
34593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34595 if (!SWIG_IsOK(res1)) {
34596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34597 }
34598 arg1 = reinterpret_cast< wxWindow * >(argp1);
34599 {
34600 arg2 = &temp2;
34601 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34602 }
34603 {
34604 PyThreadState* __tstate = wxPyBeginAllowThreads();
34605 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34606 wxPyEndAllowThreads(__tstate);
34607 if (PyErr_Occurred()) SWIG_fail;
34608 }
34609 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34610 return resultobj;
34611 fail:
34612 return NULL;
34613 }
34614
34615
34616 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34617 PyObject *resultobj = 0;
34618 wxWindow *arg1 = (wxWindow *) 0 ;
34619 wxPoint *arg2 = 0 ;
34620 wxPoint result;
34621 void *argp1 = 0 ;
34622 int res1 = 0 ;
34623 wxPoint temp2 ;
34624 PyObject * obj0 = 0 ;
34625 PyObject * obj1 = 0 ;
34626 char * kwnames[] = {
34627 (char *) "self",(char *) "pt", NULL
34628 };
34629
34630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34632 if (!SWIG_IsOK(res1)) {
34633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34634 }
34635 arg1 = reinterpret_cast< wxWindow * >(argp1);
34636 {
34637 arg2 = &temp2;
34638 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34639 }
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj = 0;
34655 wxWindow *arg1 = (wxWindow *) 0 ;
34656 wxSize *arg2 = 0 ;
34657 wxSize result;
34658 void *argp1 = 0 ;
34659 int res1 = 0 ;
34660 wxSize temp2 ;
34661 PyObject * obj0 = 0 ;
34662 PyObject * obj1 = 0 ;
34663 char * kwnames[] = {
34664 (char *) "self",(char *) "sz", NULL
34665 };
34666
34667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34669 if (!SWIG_IsOK(res1)) {
34670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34671 }
34672 arg1 = reinterpret_cast< wxWindow * >(argp1);
34673 {
34674 arg2 = &temp2;
34675 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34676 }
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj = 0;
34692 wxWindow *arg1 = (wxWindow *) 0 ;
34693 int arg2 ;
34694 int arg3 ;
34695 void *argp1 = 0 ;
34696 int res1 = 0 ;
34697 int val2 ;
34698 int ecode2 = 0 ;
34699 int val3 ;
34700 int ecode3 = 0 ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 PyObject * obj2 = 0 ;
34704 char * kwnames[] = {
34705 (char *) "self",(char *) "x",(char *) "y", NULL
34706 };
34707
34708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34710 if (!SWIG_IsOK(res1)) {
34711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34712 }
34713 arg1 = reinterpret_cast< wxWindow * >(argp1);
34714 ecode2 = SWIG_AsVal_int(obj1, &val2);
34715 if (!SWIG_IsOK(ecode2)) {
34716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34717 }
34718 arg2 = static_cast< int >(val2);
34719 ecode3 = SWIG_AsVal_int(obj2, &val3);
34720 if (!SWIG_IsOK(ecode3)) {
34721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34722 }
34723 arg3 = static_cast< int >(val3);
34724 {
34725 PyThreadState* __tstate = wxPyBeginAllowThreads();
34726 (arg1)->WarpPointer(arg2,arg3);
34727 wxPyEndAllowThreads(__tstate);
34728 if (PyErr_Occurred()) SWIG_fail;
34729 }
34730 resultobj = SWIG_Py_Void();
34731 return resultobj;
34732 fail:
34733 return NULL;
34734 }
34735
34736
34737 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34738 PyObject *resultobj = 0;
34739 wxWindow *arg1 = (wxWindow *) 0 ;
34740 void *argp1 = 0 ;
34741 int res1 = 0 ;
34742 PyObject *swig_obj[1] ;
34743
34744 if (!args) SWIG_fail;
34745 swig_obj[0] = args;
34746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34747 if (!SWIG_IsOK(res1)) {
34748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34749 }
34750 arg1 = reinterpret_cast< wxWindow * >(argp1);
34751 {
34752 PyThreadState* __tstate = wxPyBeginAllowThreads();
34753 (arg1)->CaptureMouse();
34754 wxPyEndAllowThreads(__tstate);
34755 if (PyErr_Occurred()) SWIG_fail;
34756 }
34757 resultobj = SWIG_Py_Void();
34758 return resultobj;
34759 fail:
34760 return NULL;
34761 }
34762
34763
34764 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34765 PyObject *resultobj = 0;
34766 wxWindow *arg1 = (wxWindow *) 0 ;
34767 void *argp1 = 0 ;
34768 int res1 = 0 ;
34769 PyObject *swig_obj[1] ;
34770
34771 if (!args) SWIG_fail;
34772 swig_obj[0] = args;
34773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34774 if (!SWIG_IsOK(res1)) {
34775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34776 }
34777 arg1 = reinterpret_cast< wxWindow * >(argp1);
34778 {
34779 PyThreadState* __tstate = wxPyBeginAllowThreads();
34780 (arg1)->ReleaseMouse();
34781 wxPyEndAllowThreads(__tstate);
34782 if (PyErr_Occurred()) SWIG_fail;
34783 }
34784 resultobj = SWIG_Py_Void();
34785 return resultobj;
34786 fail:
34787 return NULL;
34788 }
34789
34790
34791 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34792 PyObject *resultobj = 0;
34793 wxWindow *result = 0 ;
34794
34795 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34796 {
34797 if (!wxPyCheckForApp()) SWIG_fail;
34798 PyThreadState* __tstate = wxPyBeginAllowThreads();
34799 result = (wxWindow *)wxWindow::GetCapture();
34800 wxPyEndAllowThreads(__tstate);
34801 if (PyErr_Occurred()) SWIG_fail;
34802 }
34803 {
34804 resultobj = wxPyMake_wxObject(result, 0);
34805 }
34806 return resultobj;
34807 fail:
34808 return NULL;
34809 }
34810
34811
34812 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34813 PyObject *resultobj = 0;
34814 wxWindow *arg1 = (wxWindow *) 0 ;
34815 bool result;
34816 void *argp1 = 0 ;
34817 int res1 = 0 ;
34818 PyObject *swig_obj[1] ;
34819
34820 if (!args) SWIG_fail;
34821 swig_obj[0] = args;
34822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34823 if (!SWIG_IsOK(res1)) {
34824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34825 }
34826 arg1 = reinterpret_cast< wxWindow * >(argp1);
34827 {
34828 PyThreadState* __tstate = wxPyBeginAllowThreads();
34829 result = (bool)((wxWindow const *)arg1)->HasCapture();
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 {
34834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34835 }
34836 return resultobj;
34837 fail:
34838 return NULL;
34839 }
34840
34841
34842 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34843 PyObject *resultobj = 0;
34844 wxWindow *arg1 = (wxWindow *) 0 ;
34845 bool arg2 = (bool) true ;
34846 wxRect *arg3 = (wxRect *) NULL ;
34847 void *argp1 = 0 ;
34848 int res1 = 0 ;
34849 bool val2 ;
34850 int ecode2 = 0 ;
34851 void *argp3 = 0 ;
34852 int res3 = 0 ;
34853 PyObject * obj0 = 0 ;
34854 PyObject * obj1 = 0 ;
34855 PyObject * obj2 = 0 ;
34856 char * kwnames[] = {
34857 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34858 };
34859
34860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34862 if (!SWIG_IsOK(res1)) {
34863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34864 }
34865 arg1 = reinterpret_cast< wxWindow * >(argp1);
34866 if (obj1) {
34867 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34868 if (!SWIG_IsOK(ecode2)) {
34869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34870 }
34871 arg2 = static_cast< bool >(val2);
34872 }
34873 if (obj2) {
34874 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34875 if (!SWIG_IsOK(res3)) {
34876 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34877 }
34878 arg3 = reinterpret_cast< wxRect * >(argp3);
34879 }
34880 {
34881 PyThreadState* __tstate = wxPyBeginAllowThreads();
34882 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34883 wxPyEndAllowThreads(__tstate);
34884 if (PyErr_Occurred()) SWIG_fail;
34885 }
34886 resultobj = SWIG_Py_Void();
34887 return resultobj;
34888 fail:
34889 return NULL;
34890 }
34891
34892
34893 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34894 PyObject *resultobj = 0;
34895 wxWindow *arg1 = (wxWindow *) 0 ;
34896 wxRect *arg2 = 0 ;
34897 bool arg3 = (bool) true ;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 wxRect temp2 ;
34901 bool val3 ;
34902 int ecode3 = 0 ;
34903 PyObject * obj0 = 0 ;
34904 PyObject * obj1 = 0 ;
34905 PyObject * obj2 = 0 ;
34906 char * kwnames[] = {
34907 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34908 };
34909
34910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34912 if (!SWIG_IsOK(res1)) {
34913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34914 }
34915 arg1 = reinterpret_cast< wxWindow * >(argp1);
34916 {
34917 arg2 = &temp2;
34918 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34919 }
34920 if (obj2) {
34921 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34922 if (!SWIG_IsOK(ecode3)) {
34923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34924 }
34925 arg3 = static_cast< bool >(val3);
34926 }
34927 {
34928 PyThreadState* __tstate = wxPyBeginAllowThreads();
34929 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34930 wxPyEndAllowThreads(__tstate);
34931 if (PyErr_Occurred()) SWIG_fail;
34932 }
34933 resultobj = SWIG_Py_Void();
34934 return resultobj;
34935 fail:
34936 return NULL;
34937 }
34938
34939
34940 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34941 PyObject *resultobj = 0;
34942 wxWindow *arg1 = (wxWindow *) 0 ;
34943 void *argp1 = 0 ;
34944 int res1 = 0 ;
34945 PyObject *swig_obj[1] ;
34946
34947 if (!args) SWIG_fail;
34948 swig_obj[0] = args;
34949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34950 if (!SWIG_IsOK(res1)) {
34951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34952 }
34953 arg1 = reinterpret_cast< wxWindow * >(argp1);
34954 {
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 (arg1)->Update();
34957 wxPyEndAllowThreads(__tstate);
34958 if (PyErr_Occurred()) SWIG_fail;
34959 }
34960 resultobj = SWIG_Py_Void();
34961 return resultobj;
34962 fail:
34963 return NULL;
34964 }
34965
34966
34967 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34968 PyObject *resultobj = 0;
34969 wxWindow *arg1 = (wxWindow *) 0 ;
34970 void *argp1 = 0 ;
34971 int res1 = 0 ;
34972 PyObject *swig_obj[1] ;
34973
34974 if (!args) SWIG_fail;
34975 swig_obj[0] = args;
34976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34977 if (!SWIG_IsOK(res1)) {
34978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34979 }
34980 arg1 = reinterpret_cast< wxWindow * >(argp1);
34981 {
34982 PyThreadState* __tstate = wxPyBeginAllowThreads();
34983 (arg1)->ClearBackground();
34984 wxPyEndAllowThreads(__tstate);
34985 if (PyErr_Occurred()) SWIG_fail;
34986 }
34987 resultobj = SWIG_Py_Void();
34988 return resultobj;
34989 fail:
34990 return NULL;
34991 }
34992
34993
34994 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34995 PyObject *resultobj = 0;
34996 wxWindow *arg1 = (wxWindow *) 0 ;
34997 void *argp1 = 0 ;
34998 int res1 = 0 ;
34999 PyObject *swig_obj[1] ;
35000
35001 if (!args) SWIG_fail;
35002 swig_obj[0] = args;
35003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35004 if (!SWIG_IsOK(res1)) {
35005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35006 }
35007 arg1 = reinterpret_cast< wxWindow * >(argp1);
35008 {
35009 PyThreadState* __tstate = wxPyBeginAllowThreads();
35010 (arg1)->Freeze();
35011 wxPyEndAllowThreads(__tstate);
35012 if (PyErr_Occurred()) SWIG_fail;
35013 }
35014 resultobj = SWIG_Py_Void();
35015 return resultobj;
35016 fail:
35017 return NULL;
35018 }
35019
35020
35021 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35022 PyObject *resultobj = 0;
35023 wxWindow *arg1 = (wxWindow *) 0 ;
35024 void *argp1 = 0 ;
35025 int res1 = 0 ;
35026 PyObject *swig_obj[1] ;
35027
35028 if (!args) SWIG_fail;
35029 swig_obj[0] = args;
35030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35031 if (!SWIG_IsOK(res1)) {
35032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35033 }
35034 arg1 = reinterpret_cast< wxWindow * >(argp1);
35035 {
35036 PyThreadState* __tstate = wxPyBeginAllowThreads();
35037 (arg1)->Thaw();
35038 wxPyEndAllowThreads(__tstate);
35039 if (PyErr_Occurred()) SWIG_fail;
35040 }
35041 resultobj = SWIG_Py_Void();
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj = 0;
35050 wxWindow *arg1 = (wxWindow *) 0 ;
35051 wxDC *arg2 = 0 ;
35052 void *argp1 = 0 ;
35053 int res1 = 0 ;
35054 void *argp2 = 0 ;
35055 int res2 = 0 ;
35056 PyObject * obj0 = 0 ;
35057 PyObject * obj1 = 0 ;
35058 char * kwnames[] = {
35059 (char *) "self",(char *) "dc", NULL
35060 };
35061
35062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35064 if (!SWIG_IsOK(res1)) {
35065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35066 }
35067 arg1 = reinterpret_cast< wxWindow * >(argp1);
35068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35069 if (!SWIG_IsOK(res2)) {
35070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35071 }
35072 if (!argp2) {
35073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35074 }
35075 arg2 = reinterpret_cast< wxDC * >(argp2);
35076 {
35077 PyThreadState* __tstate = wxPyBeginAllowThreads();
35078 (arg1)->PrepareDC(*arg2);
35079 wxPyEndAllowThreads(__tstate);
35080 if (PyErr_Occurred()) SWIG_fail;
35081 }
35082 resultobj = SWIG_Py_Void();
35083 return resultobj;
35084 fail:
35085 return NULL;
35086 }
35087
35088
35089 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35090 PyObject *resultobj = 0;
35091 wxWindow *arg1 = (wxWindow *) 0 ;
35092 wxRegion *result = 0 ;
35093 void *argp1 = 0 ;
35094 int res1 = 0 ;
35095 PyObject *swig_obj[1] ;
35096
35097 if (!args) SWIG_fail;
35098 swig_obj[0] = args;
35099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35100 if (!SWIG_IsOK(res1)) {
35101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35102 }
35103 arg1 = reinterpret_cast< wxWindow * >(argp1);
35104 {
35105 PyThreadState* __tstate = wxPyBeginAllowThreads();
35106 {
35107 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35108 result = (wxRegion *) &_result_ref;
35109 }
35110 wxPyEndAllowThreads(__tstate);
35111 if (PyErr_Occurred()) SWIG_fail;
35112 }
35113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35114 return resultobj;
35115 fail:
35116 return NULL;
35117 }
35118
35119
35120 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35121 PyObject *resultobj = 0;
35122 wxWindow *arg1 = (wxWindow *) 0 ;
35123 wxRect result;
35124 void *argp1 = 0 ;
35125 int res1 = 0 ;
35126 PyObject *swig_obj[1] ;
35127
35128 if (!args) SWIG_fail;
35129 swig_obj[0] = args;
35130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35131 if (!SWIG_IsOK(res1)) {
35132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35133 }
35134 arg1 = reinterpret_cast< wxWindow * >(argp1);
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35149 PyObject *resultobj = 0;
35150 wxWindow *arg1 = (wxWindow *) 0 ;
35151 int arg2 ;
35152 int arg3 ;
35153 int arg4 = (int) 1 ;
35154 int arg5 = (int) 1 ;
35155 bool result;
35156 void *argp1 = 0 ;
35157 int res1 = 0 ;
35158 int val2 ;
35159 int ecode2 = 0 ;
35160 int val3 ;
35161 int ecode3 = 0 ;
35162 int val4 ;
35163 int ecode4 = 0 ;
35164 int val5 ;
35165 int ecode5 = 0 ;
35166 PyObject * obj0 = 0 ;
35167 PyObject * obj1 = 0 ;
35168 PyObject * obj2 = 0 ;
35169 PyObject * obj3 = 0 ;
35170 PyObject * obj4 = 0 ;
35171 char * kwnames[] = {
35172 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35173 };
35174
35175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35177 if (!SWIG_IsOK(res1)) {
35178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35179 }
35180 arg1 = reinterpret_cast< wxWindow * >(argp1);
35181 ecode2 = SWIG_AsVal_int(obj1, &val2);
35182 if (!SWIG_IsOK(ecode2)) {
35183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35184 }
35185 arg2 = static_cast< int >(val2);
35186 ecode3 = SWIG_AsVal_int(obj2, &val3);
35187 if (!SWIG_IsOK(ecode3)) {
35188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35189 }
35190 arg3 = static_cast< int >(val3);
35191 if (obj3) {
35192 ecode4 = SWIG_AsVal_int(obj3, &val4);
35193 if (!SWIG_IsOK(ecode4)) {
35194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35195 }
35196 arg4 = static_cast< int >(val4);
35197 }
35198 if (obj4) {
35199 ecode5 = SWIG_AsVal_int(obj4, &val5);
35200 if (!SWIG_IsOK(ecode5)) {
35201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35202 }
35203 arg5 = static_cast< int >(val5);
35204 }
35205 {
35206 PyThreadState* __tstate = wxPyBeginAllowThreads();
35207 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35208 wxPyEndAllowThreads(__tstate);
35209 if (PyErr_Occurred()) SWIG_fail;
35210 }
35211 {
35212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35213 }
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj = 0;
35222 wxWindow *arg1 = (wxWindow *) 0 ;
35223 wxPoint *arg2 = 0 ;
35224 bool result;
35225 void *argp1 = 0 ;
35226 int res1 = 0 ;
35227 wxPoint temp2 ;
35228 PyObject * obj0 = 0 ;
35229 PyObject * obj1 = 0 ;
35230 char * kwnames[] = {
35231 (char *) "self",(char *) "pt", NULL
35232 };
35233
35234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35236 if (!SWIG_IsOK(res1)) {
35237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35238 }
35239 arg1 = reinterpret_cast< wxWindow * >(argp1);
35240 {
35241 arg2 = &temp2;
35242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35243 }
35244 {
35245 PyThreadState* __tstate = wxPyBeginAllowThreads();
35246 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 {
35251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35252 }
35253 return resultobj;
35254 fail:
35255 return NULL;
35256 }
35257
35258
35259 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35260 PyObject *resultobj = 0;
35261 wxWindow *arg1 = (wxWindow *) 0 ;
35262 wxRect *arg2 = 0 ;
35263 bool result;
35264 void *argp1 = 0 ;
35265 int res1 = 0 ;
35266 wxRect temp2 ;
35267 PyObject * obj0 = 0 ;
35268 PyObject * obj1 = 0 ;
35269 char * kwnames[] = {
35270 (char *) "self",(char *) "rect", NULL
35271 };
35272
35273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35275 if (!SWIG_IsOK(res1)) {
35276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35277 }
35278 arg1 = reinterpret_cast< wxWindow * >(argp1);
35279 {
35280 arg2 = &temp2;
35281 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35282 }
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35286 wxPyEndAllowThreads(__tstate);
35287 if (PyErr_Occurred()) SWIG_fail;
35288 }
35289 {
35290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35291 }
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35299 PyObject *resultobj = 0;
35300 wxWindow *arg1 = (wxWindow *) 0 ;
35301 SwigValueWrapper<wxVisualAttributes > result;
35302 void *argp1 = 0 ;
35303 int res1 = 0 ;
35304 PyObject *swig_obj[1] ;
35305
35306 if (!args) SWIG_fail;
35307 swig_obj[0] = args;
35308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35309 if (!SWIG_IsOK(res1)) {
35310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35311 }
35312 arg1 = reinterpret_cast< wxWindow * >(argp1);
35313 {
35314 PyThreadState* __tstate = wxPyBeginAllowThreads();
35315 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35316 wxPyEndAllowThreads(__tstate);
35317 if (PyErr_Occurred()) SWIG_fail;
35318 }
35319 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35320 return resultobj;
35321 fail:
35322 return NULL;
35323 }
35324
35325
35326 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35327 PyObject *resultobj = 0;
35328 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35329 SwigValueWrapper<wxVisualAttributes > result;
35330 int val1 ;
35331 int ecode1 = 0 ;
35332 PyObject * obj0 = 0 ;
35333 char * kwnames[] = {
35334 (char *) "variant", NULL
35335 };
35336
35337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35338 if (obj0) {
35339 ecode1 = SWIG_AsVal_int(obj0, &val1);
35340 if (!SWIG_IsOK(ecode1)) {
35341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35342 }
35343 arg1 = static_cast< wxWindowVariant >(val1);
35344 }
35345 {
35346 if (!wxPyCheckForApp()) SWIG_fail;
35347 PyThreadState* __tstate = wxPyBeginAllowThreads();
35348 result = wxWindow::GetClassDefaultAttributes(arg1);
35349 wxPyEndAllowThreads(__tstate);
35350 if (PyErr_Occurred()) SWIG_fail;
35351 }
35352 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35353 return resultobj;
35354 fail:
35355 return NULL;
35356 }
35357
35358
35359 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35360 PyObject *resultobj = 0;
35361 wxWindow *arg1 = (wxWindow *) 0 ;
35362 wxColour *arg2 = 0 ;
35363 bool result;
35364 void *argp1 = 0 ;
35365 int res1 = 0 ;
35366 wxColour temp2 ;
35367 PyObject * obj0 = 0 ;
35368 PyObject * obj1 = 0 ;
35369 char * kwnames[] = {
35370 (char *) "self",(char *) "colour", NULL
35371 };
35372
35373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35375 if (!SWIG_IsOK(res1)) {
35376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35377 }
35378 arg1 = reinterpret_cast< wxWindow * >(argp1);
35379 {
35380 arg2 = &temp2;
35381 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35382 }
35383 {
35384 PyThreadState* __tstate = wxPyBeginAllowThreads();
35385 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35386 wxPyEndAllowThreads(__tstate);
35387 if (PyErr_Occurred()) SWIG_fail;
35388 }
35389 {
35390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35391 }
35392 return resultobj;
35393 fail:
35394 return NULL;
35395 }
35396
35397
35398 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35399 PyObject *resultobj = 0;
35400 wxWindow *arg1 = (wxWindow *) 0 ;
35401 wxColour *arg2 = 0 ;
35402 void *argp1 = 0 ;
35403 int res1 = 0 ;
35404 wxColour temp2 ;
35405 PyObject * obj0 = 0 ;
35406 PyObject * obj1 = 0 ;
35407 char * kwnames[] = {
35408 (char *) "self",(char *) "colour", NULL
35409 };
35410
35411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35413 if (!SWIG_IsOK(res1)) {
35414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35415 }
35416 arg1 = reinterpret_cast< wxWindow * >(argp1);
35417 {
35418 arg2 = &temp2;
35419 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35420 }
35421 {
35422 PyThreadState* __tstate = wxPyBeginAllowThreads();
35423 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35424 wxPyEndAllowThreads(__tstate);
35425 if (PyErr_Occurred()) SWIG_fail;
35426 }
35427 resultobj = SWIG_Py_Void();
35428 return resultobj;
35429 fail:
35430 return NULL;
35431 }
35432
35433
35434 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35435 PyObject *resultobj = 0;
35436 wxWindow *arg1 = (wxWindow *) 0 ;
35437 wxColour *arg2 = 0 ;
35438 bool result;
35439 void *argp1 = 0 ;
35440 int res1 = 0 ;
35441 wxColour temp2 ;
35442 PyObject * obj0 = 0 ;
35443 PyObject * obj1 = 0 ;
35444 char * kwnames[] = {
35445 (char *) "self",(char *) "colour", NULL
35446 };
35447
35448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35450 if (!SWIG_IsOK(res1)) {
35451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35452 }
35453 arg1 = reinterpret_cast< wxWindow * >(argp1);
35454 {
35455 arg2 = &temp2;
35456 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35457 }
35458 {
35459 PyThreadState* __tstate = wxPyBeginAllowThreads();
35460 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35461 wxPyEndAllowThreads(__tstate);
35462 if (PyErr_Occurred()) SWIG_fail;
35463 }
35464 {
35465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35466 }
35467 return resultobj;
35468 fail:
35469 return NULL;
35470 }
35471
35472
35473 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35474 PyObject *resultobj = 0;
35475 wxWindow *arg1 = (wxWindow *) 0 ;
35476 wxColour *arg2 = 0 ;
35477 void *argp1 = 0 ;
35478 int res1 = 0 ;
35479 wxColour temp2 ;
35480 PyObject * obj0 = 0 ;
35481 PyObject * obj1 = 0 ;
35482 char * kwnames[] = {
35483 (char *) "self",(char *) "colour", NULL
35484 };
35485
35486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35488 if (!SWIG_IsOK(res1)) {
35489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35490 }
35491 arg1 = reinterpret_cast< wxWindow * >(argp1);
35492 {
35493 arg2 = &temp2;
35494 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35495 }
35496 {
35497 PyThreadState* __tstate = wxPyBeginAllowThreads();
35498 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35499 wxPyEndAllowThreads(__tstate);
35500 if (PyErr_Occurred()) SWIG_fail;
35501 }
35502 resultobj = SWIG_Py_Void();
35503 return resultobj;
35504 fail:
35505 return NULL;
35506 }
35507
35508
35509 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35510 PyObject *resultobj = 0;
35511 wxWindow *arg1 = (wxWindow *) 0 ;
35512 wxColour result;
35513 void *argp1 = 0 ;
35514 int res1 = 0 ;
35515 PyObject *swig_obj[1] ;
35516
35517 if (!args) SWIG_fail;
35518 swig_obj[0] = args;
35519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35520 if (!SWIG_IsOK(res1)) {
35521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35522 }
35523 arg1 = reinterpret_cast< wxWindow * >(argp1);
35524 {
35525 PyThreadState* __tstate = wxPyBeginAllowThreads();
35526 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35527 wxPyEndAllowThreads(__tstate);
35528 if (PyErr_Occurred()) SWIG_fail;
35529 }
35530 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35531 return resultobj;
35532 fail:
35533 return NULL;
35534 }
35535
35536
35537 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35538 PyObject *resultobj = 0;
35539 wxWindow *arg1 = (wxWindow *) 0 ;
35540 wxColour result;
35541 void *argp1 = 0 ;
35542 int res1 = 0 ;
35543 PyObject *swig_obj[1] ;
35544
35545 if (!args) SWIG_fail;
35546 swig_obj[0] = args;
35547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35548 if (!SWIG_IsOK(res1)) {
35549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35550 }
35551 arg1 = reinterpret_cast< wxWindow * >(argp1);
35552 {
35553 PyThreadState* __tstate = wxPyBeginAllowThreads();
35554 result = ((wxWindow const *)arg1)->GetForegroundColour();
35555 wxPyEndAllowThreads(__tstate);
35556 if (PyErr_Occurred()) SWIG_fail;
35557 }
35558 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35559 return resultobj;
35560 fail:
35561 return NULL;
35562 }
35563
35564
35565 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35566 PyObject *resultobj = 0;
35567 wxWindow *arg1 = (wxWindow *) 0 ;
35568 bool result;
35569 void *argp1 = 0 ;
35570 int res1 = 0 ;
35571 PyObject *swig_obj[1] ;
35572
35573 if (!args) SWIG_fail;
35574 swig_obj[0] = args;
35575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35576 if (!SWIG_IsOK(res1)) {
35577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35578 }
35579 arg1 = reinterpret_cast< wxWindow * >(argp1);
35580 {
35581 PyThreadState* __tstate = wxPyBeginAllowThreads();
35582 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35583 wxPyEndAllowThreads(__tstate);
35584 if (PyErr_Occurred()) SWIG_fail;
35585 }
35586 {
35587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35588 }
35589 return resultobj;
35590 fail:
35591 return NULL;
35592 }
35593
35594
35595 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35596 PyObject *resultobj = 0;
35597 wxWindow *arg1 = (wxWindow *) 0 ;
35598 bool result;
35599 void *argp1 = 0 ;
35600 int res1 = 0 ;
35601 PyObject *swig_obj[1] ;
35602
35603 if (!args) SWIG_fail;
35604 swig_obj[0] = args;
35605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35606 if (!SWIG_IsOK(res1)) {
35607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35608 }
35609 arg1 = reinterpret_cast< wxWindow * >(argp1);
35610 {
35611 PyThreadState* __tstate = wxPyBeginAllowThreads();
35612 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35613 wxPyEndAllowThreads(__tstate);
35614 if (PyErr_Occurred()) SWIG_fail;
35615 }
35616 {
35617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35618 }
35619 return resultobj;
35620 fail:
35621 return NULL;
35622 }
35623
35624
35625 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35626 PyObject *resultobj = 0;
35627 wxWindow *arg1 = (wxWindow *) 0 ;
35628 wxBackgroundStyle arg2 ;
35629 bool result;
35630 void *argp1 = 0 ;
35631 int res1 = 0 ;
35632 int val2 ;
35633 int ecode2 = 0 ;
35634 PyObject * obj0 = 0 ;
35635 PyObject * obj1 = 0 ;
35636 char * kwnames[] = {
35637 (char *) "self",(char *) "style", NULL
35638 };
35639
35640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35642 if (!SWIG_IsOK(res1)) {
35643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35644 }
35645 arg1 = reinterpret_cast< wxWindow * >(argp1);
35646 ecode2 = SWIG_AsVal_int(obj1, &val2);
35647 if (!SWIG_IsOK(ecode2)) {
35648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35649 }
35650 arg2 = static_cast< wxBackgroundStyle >(val2);
35651 {
35652 PyThreadState* __tstate = wxPyBeginAllowThreads();
35653 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35654 wxPyEndAllowThreads(__tstate);
35655 if (PyErr_Occurred()) SWIG_fail;
35656 }
35657 {
35658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35659 }
35660 return resultobj;
35661 fail:
35662 return NULL;
35663 }
35664
35665
35666 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35667 PyObject *resultobj = 0;
35668 wxWindow *arg1 = (wxWindow *) 0 ;
35669 wxBackgroundStyle result;
35670 void *argp1 = 0 ;
35671 int res1 = 0 ;
35672 PyObject *swig_obj[1] ;
35673
35674 if (!args) SWIG_fail;
35675 swig_obj[0] = args;
35676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35677 if (!SWIG_IsOK(res1)) {
35678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35679 }
35680 arg1 = reinterpret_cast< wxWindow * >(argp1);
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35684 wxPyEndAllowThreads(__tstate);
35685 if (PyErr_Occurred()) SWIG_fail;
35686 }
35687 resultobj = SWIG_From_int(static_cast< int >(result));
35688 return resultobj;
35689 fail:
35690 return NULL;
35691 }
35692
35693
35694 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35695 PyObject *resultobj = 0;
35696 wxWindow *arg1 = (wxWindow *) 0 ;
35697 bool result;
35698 void *argp1 = 0 ;
35699 int res1 = 0 ;
35700 PyObject *swig_obj[1] ;
35701
35702 if (!args) SWIG_fail;
35703 swig_obj[0] = args;
35704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35705 if (!SWIG_IsOK(res1)) {
35706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35707 }
35708 arg1 = reinterpret_cast< wxWindow * >(argp1);
35709 {
35710 PyThreadState* __tstate = wxPyBeginAllowThreads();
35711 result = (bool)(arg1)->HasTransparentBackground();
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 {
35716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35717 }
35718 return resultobj;
35719 fail:
35720 return NULL;
35721 }
35722
35723
35724 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35725 PyObject *resultobj = 0;
35726 wxWindow *arg1 = (wxWindow *) 0 ;
35727 wxCursor *arg2 = 0 ;
35728 bool result;
35729 void *argp1 = 0 ;
35730 int res1 = 0 ;
35731 void *argp2 = 0 ;
35732 int res2 = 0 ;
35733 PyObject * obj0 = 0 ;
35734 PyObject * obj1 = 0 ;
35735 char * kwnames[] = {
35736 (char *) "self",(char *) "cursor", NULL
35737 };
35738
35739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35741 if (!SWIG_IsOK(res1)) {
35742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35743 }
35744 arg1 = reinterpret_cast< wxWindow * >(argp1);
35745 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35746 if (!SWIG_IsOK(res2)) {
35747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35748 }
35749 if (!argp2) {
35750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35751 }
35752 arg2 = reinterpret_cast< wxCursor * >(argp2);
35753 {
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35756 wxPyEndAllowThreads(__tstate);
35757 if (PyErr_Occurred()) SWIG_fail;
35758 }
35759 {
35760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35761 }
35762 return resultobj;
35763 fail:
35764 return NULL;
35765 }
35766
35767
35768 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35769 PyObject *resultobj = 0;
35770 wxWindow *arg1 = (wxWindow *) 0 ;
35771 wxCursor result;
35772 void *argp1 = 0 ;
35773 int res1 = 0 ;
35774 PyObject *swig_obj[1] ;
35775
35776 if (!args) SWIG_fail;
35777 swig_obj[0] = args;
35778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35779 if (!SWIG_IsOK(res1)) {
35780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35781 }
35782 arg1 = reinterpret_cast< wxWindow * >(argp1);
35783 {
35784 PyThreadState* __tstate = wxPyBeginAllowThreads();
35785 result = (arg1)->GetCursor();
35786 wxPyEndAllowThreads(__tstate);
35787 if (PyErr_Occurred()) SWIG_fail;
35788 }
35789 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35790 return resultobj;
35791 fail:
35792 return NULL;
35793 }
35794
35795
35796 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35797 PyObject *resultobj = 0;
35798 wxWindow *arg1 = (wxWindow *) 0 ;
35799 wxFont *arg2 = 0 ;
35800 bool result;
35801 void *argp1 = 0 ;
35802 int res1 = 0 ;
35803 void *argp2 = 0 ;
35804 int res2 = 0 ;
35805 PyObject * obj0 = 0 ;
35806 PyObject * obj1 = 0 ;
35807 char * kwnames[] = {
35808 (char *) "self",(char *) "font", NULL
35809 };
35810
35811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35813 if (!SWIG_IsOK(res1)) {
35814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35815 }
35816 arg1 = reinterpret_cast< wxWindow * >(argp1);
35817 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35818 if (!SWIG_IsOK(res2)) {
35819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35820 }
35821 if (!argp2) {
35822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35823 }
35824 arg2 = reinterpret_cast< wxFont * >(argp2);
35825 {
35826 PyThreadState* __tstate = wxPyBeginAllowThreads();
35827 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35828 wxPyEndAllowThreads(__tstate);
35829 if (PyErr_Occurred()) SWIG_fail;
35830 }
35831 {
35832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35833 }
35834 return resultobj;
35835 fail:
35836 return NULL;
35837 }
35838
35839
35840 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35841 PyObject *resultobj = 0;
35842 wxWindow *arg1 = (wxWindow *) 0 ;
35843 wxFont *arg2 = 0 ;
35844 void *argp1 = 0 ;
35845 int res1 = 0 ;
35846 void *argp2 = 0 ;
35847 int res2 = 0 ;
35848 PyObject * obj0 = 0 ;
35849 PyObject * obj1 = 0 ;
35850 char * kwnames[] = {
35851 (char *) "self",(char *) "font", NULL
35852 };
35853
35854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35856 if (!SWIG_IsOK(res1)) {
35857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35858 }
35859 arg1 = reinterpret_cast< wxWindow * >(argp1);
35860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35861 if (!SWIG_IsOK(res2)) {
35862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35863 }
35864 if (!argp2) {
35865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35866 }
35867 arg2 = reinterpret_cast< wxFont * >(argp2);
35868 {
35869 PyThreadState* __tstate = wxPyBeginAllowThreads();
35870 (arg1)->SetOwnFont((wxFont const &)*arg2);
35871 wxPyEndAllowThreads(__tstate);
35872 if (PyErr_Occurred()) SWIG_fail;
35873 }
35874 resultobj = SWIG_Py_Void();
35875 return resultobj;
35876 fail:
35877 return NULL;
35878 }
35879
35880
35881 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35882 PyObject *resultobj = 0;
35883 wxWindow *arg1 = (wxWindow *) 0 ;
35884 wxFont result;
35885 void *argp1 = 0 ;
35886 int res1 = 0 ;
35887 PyObject *swig_obj[1] ;
35888
35889 if (!args) SWIG_fail;
35890 swig_obj[0] = args;
35891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35892 if (!SWIG_IsOK(res1)) {
35893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35894 }
35895 arg1 = reinterpret_cast< wxWindow * >(argp1);
35896 {
35897 PyThreadState* __tstate = wxPyBeginAllowThreads();
35898 result = (arg1)->GetFont();
35899 wxPyEndAllowThreads(__tstate);
35900 if (PyErr_Occurred()) SWIG_fail;
35901 }
35902 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35903 return resultobj;
35904 fail:
35905 return NULL;
35906 }
35907
35908
35909 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35910 PyObject *resultobj = 0;
35911 wxWindow *arg1 = (wxWindow *) 0 ;
35912 wxCaret *arg2 = (wxCaret *) 0 ;
35913 void *argp1 = 0 ;
35914 int res1 = 0 ;
35915 int res2 = 0 ;
35916 PyObject * obj0 = 0 ;
35917 PyObject * obj1 = 0 ;
35918 char * kwnames[] = {
35919 (char *) "self",(char *) "caret", NULL
35920 };
35921
35922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35924 if (!SWIG_IsOK(res1)) {
35925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35926 }
35927 arg1 = reinterpret_cast< wxWindow * >(argp1);
35928 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35929 if (!SWIG_IsOK(res2)) {
35930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35931 }
35932 {
35933 PyThreadState* __tstate = wxPyBeginAllowThreads();
35934 (arg1)->SetCaret(arg2);
35935 wxPyEndAllowThreads(__tstate);
35936 if (PyErr_Occurred()) SWIG_fail;
35937 }
35938 resultobj = SWIG_Py_Void();
35939 return resultobj;
35940 fail:
35941 return NULL;
35942 }
35943
35944
35945 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35946 PyObject *resultobj = 0;
35947 wxWindow *arg1 = (wxWindow *) 0 ;
35948 wxCaret *result = 0 ;
35949 void *argp1 = 0 ;
35950 int res1 = 0 ;
35951 PyObject *swig_obj[1] ;
35952
35953 if (!args) SWIG_fail;
35954 swig_obj[0] = args;
35955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35956 if (!SWIG_IsOK(res1)) {
35957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35958 }
35959 arg1 = reinterpret_cast< wxWindow * >(argp1);
35960 {
35961 PyThreadState* __tstate = wxPyBeginAllowThreads();
35962 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35963 wxPyEndAllowThreads(__tstate);
35964 if (PyErr_Occurred()) SWIG_fail;
35965 }
35966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35967 return resultobj;
35968 fail:
35969 return NULL;
35970 }
35971
35972
35973 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35974 PyObject *resultobj = 0;
35975 wxWindow *arg1 = (wxWindow *) 0 ;
35976 int result;
35977 void *argp1 = 0 ;
35978 int res1 = 0 ;
35979 PyObject *swig_obj[1] ;
35980
35981 if (!args) SWIG_fail;
35982 swig_obj[0] = args;
35983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35984 if (!SWIG_IsOK(res1)) {
35985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35986 }
35987 arg1 = reinterpret_cast< wxWindow * >(argp1);
35988 {
35989 PyThreadState* __tstate = wxPyBeginAllowThreads();
35990 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35991 wxPyEndAllowThreads(__tstate);
35992 if (PyErr_Occurred()) SWIG_fail;
35993 }
35994 resultobj = SWIG_From_int(static_cast< int >(result));
35995 return resultobj;
35996 fail:
35997 return NULL;
35998 }
35999
36000
36001 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36002 PyObject *resultobj = 0;
36003 wxWindow *arg1 = (wxWindow *) 0 ;
36004 int result;
36005 void *argp1 = 0 ;
36006 int res1 = 0 ;
36007 PyObject *swig_obj[1] ;
36008
36009 if (!args) SWIG_fail;
36010 swig_obj[0] = args;
36011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36012 if (!SWIG_IsOK(res1)) {
36013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36014 }
36015 arg1 = reinterpret_cast< wxWindow * >(argp1);
36016 {
36017 PyThreadState* __tstate = wxPyBeginAllowThreads();
36018 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36019 wxPyEndAllowThreads(__tstate);
36020 if (PyErr_Occurred()) SWIG_fail;
36021 }
36022 resultobj = SWIG_From_int(static_cast< int >(result));
36023 return resultobj;
36024 fail:
36025 return NULL;
36026 }
36027
36028
36029 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36030 PyObject *resultobj = 0;
36031 wxWindow *arg1 = (wxWindow *) 0 ;
36032 wxString *arg2 = 0 ;
36033 int *arg3 = (int *) 0 ;
36034 int *arg4 = (int *) 0 ;
36035 void *argp1 = 0 ;
36036 int res1 = 0 ;
36037 bool temp2 = false ;
36038 int temp3 ;
36039 int res3 = SWIG_TMPOBJ ;
36040 int temp4 ;
36041 int res4 = SWIG_TMPOBJ ;
36042 PyObject * obj0 = 0 ;
36043 PyObject * obj1 = 0 ;
36044 char * kwnames[] = {
36045 (char *) "self",(char *) "string", NULL
36046 };
36047
36048 arg3 = &temp3;
36049 arg4 = &temp4;
36050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36052 if (!SWIG_IsOK(res1)) {
36053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36054 }
36055 arg1 = reinterpret_cast< wxWindow * >(argp1);
36056 {
36057 arg2 = wxString_in_helper(obj1);
36058 if (arg2 == NULL) SWIG_fail;
36059 temp2 = true;
36060 }
36061 {
36062 PyThreadState* __tstate = wxPyBeginAllowThreads();
36063 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36064 wxPyEndAllowThreads(__tstate);
36065 if (PyErr_Occurred()) SWIG_fail;
36066 }
36067 resultobj = SWIG_Py_Void();
36068 if (SWIG_IsTmpObj(res3)) {
36069 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36070 } else {
36071 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36073 }
36074 if (SWIG_IsTmpObj(res4)) {
36075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36076 } else {
36077 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36079 }
36080 {
36081 if (temp2)
36082 delete arg2;
36083 }
36084 return resultobj;
36085 fail:
36086 {
36087 if (temp2)
36088 delete arg2;
36089 }
36090 return NULL;
36091 }
36092
36093
36094 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36095 PyObject *resultobj = 0;
36096 wxWindow *arg1 = (wxWindow *) 0 ;
36097 wxString *arg2 = 0 ;
36098 int *arg3 = (int *) 0 ;
36099 int *arg4 = (int *) 0 ;
36100 int *arg5 = (int *) 0 ;
36101 int *arg6 = (int *) 0 ;
36102 wxFont *arg7 = (wxFont *) NULL ;
36103 void *argp1 = 0 ;
36104 int res1 = 0 ;
36105 bool temp2 = false ;
36106 int temp3 ;
36107 int res3 = SWIG_TMPOBJ ;
36108 int temp4 ;
36109 int res4 = SWIG_TMPOBJ ;
36110 int temp5 ;
36111 int res5 = SWIG_TMPOBJ ;
36112 int temp6 ;
36113 int res6 = SWIG_TMPOBJ ;
36114 void *argp7 = 0 ;
36115 int res7 = 0 ;
36116 PyObject * obj0 = 0 ;
36117 PyObject * obj1 = 0 ;
36118 PyObject * obj2 = 0 ;
36119 char * kwnames[] = {
36120 (char *) "self",(char *) "string",(char *) "font", NULL
36121 };
36122
36123 arg3 = &temp3;
36124 arg4 = &temp4;
36125 arg5 = &temp5;
36126 arg6 = &temp6;
36127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36129 if (!SWIG_IsOK(res1)) {
36130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36131 }
36132 arg1 = reinterpret_cast< wxWindow * >(argp1);
36133 {
36134 arg2 = wxString_in_helper(obj1);
36135 if (arg2 == NULL) SWIG_fail;
36136 temp2 = true;
36137 }
36138 if (obj2) {
36139 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36140 if (!SWIG_IsOK(res7)) {
36141 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36142 }
36143 arg7 = reinterpret_cast< wxFont * >(argp7);
36144 }
36145 {
36146 PyThreadState* __tstate = wxPyBeginAllowThreads();
36147 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36148 wxPyEndAllowThreads(__tstate);
36149 if (PyErr_Occurred()) SWIG_fail;
36150 }
36151 resultobj = SWIG_Py_Void();
36152 if (SWIG_IsTmpObj(res3)) {
36153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36154 } else {
36155 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36157 }
36158 if (SWIG_IsTmpObj(res4)) {
36159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36160 } else {
36161 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36162 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36163 }
36164 if (SWIG_IsTmpObj(res5)) {
36165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36166 } else {
36167 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36168 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36169 }
36170 if (SWIG_IsTmpObj(res6)) {
36171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36172 } else {
36173 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36175 }
36176 {
36177 if (temp2)
36178 delete arg2;
36179 }
36180 return resultobj;
36181 fail:
36182 {
36183 if (temp2)
36184 delete arg2;
36185 }
36186 return NULL;
36187 }
36188
36189
36190 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36191 PyObject *resultobj = 0;
36192 wxWindow *arg1 = (wxWindow *) 0 ;
36193 int *arg2 = (int *) 0 ;
36194 int *arg3 = (int *) 0 ;
36195 void *argp1 = 0 ;
36196 int res1 = 0 ;
36197 int temp2 ;
36198 int res2 = 0 ;
36199 int temp3 ;
36200 int res3 = 0 ;
36201 PyObject * obj0 = 0 ;
36202 PyObject * obj1 = 0 ;
36203 PyObject * obj2 = 0 ;
36204 char * kwnames[] = {
36205 (char *) "self",(char *) "x",(char *) "y", NULL
36206 };
36207
36208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36210 if (!SWIG_IsOK(res1)) {
36211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36212 }
36213 arg1 = reinterpret_cast< wxWindow * >(argp1);
36214 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36215 int val;
36216 int ecode = SWIG_AsVal_int(obj1, &val);
36217 if (!SWIG_IsOK(ecode)) {
36218 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36219 }
36220 temp2 = static_cast< int >(val);
36221 arg2 = &temp2;
36222 res2 = SWIG_AddTmpMask(ecode);
36223 }
36224 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36225 int val;
36226 int ecode = SWIG_AsVal_int(obj2, &val);
36227 if (!SWIG_IsOK(ecode)) {
36228 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36229 }
36230 temp3 = static_cast< int >(val);
36231 arg3 = &temp3;
36232 res3 = SWIG_AddTmpMask(ecode);
36233 }
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 resultobj = SWIG_Py_Void();
36241 if (SWIG_IsTmpObj(res2)) {
36242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36243 } else {
36244 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36245 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36246 }
36247 if (SWIG_IsTmpObj(res3)) {
36248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36249 } else {
36250 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36252 }
36253 return resultobj;
36254 fail:
36255 return NULL;
36256 }
36257
36258
36259 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36260 PyObject *resultobj = 0;
36261 wxWindow *arg1 = (wxWindow *) 0 ;
36262 int *arg2 = (int *) 0 ;
36263 int *arg3 = (int *) 0 ;
36264 void *argp1 = 0 ;
36265 int res1 = 0 ;
36266 int temp2 ;
36267 int res2 = 0 ;
36268 int temp3 ;
36269 int res3 = 0 ;
36270 PyObject * obj0 = 0 ;
36271 PyObject * obj1 = 0 ;
36272 PyObject * obj2 = 0 ;
36273 char * kwnames[] = {
36274 (char *) "self",(char *) "x",(char *) "y", NULL
36275 };
36276
36277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36279 if (!SWIG_IsOK(res1)) {
36280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36281 }
36282 arg1 = reinterpret_cast< wxWindow * >(argp1);
36283 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36284 int val;
36285 int ecode = SWIG_AsVal_int(obj1, &val);
36286 if (!SWIG_IsOK(ecode)) {
36287 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36288 }
36289 temp2 = static_cast< int >(val);
36290 arg2 = &temp2;
36291 res2 = SWIG_AddTmpMask(ecode);
36292 }
36293 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36294 int val;
36295 int ecode = SWIG_AsVal_int(obj2, &val);
36296 if (!SWIG_IsOK(ecode)) {
36297 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36298 }
36299 temp3 = static_cast< int >(val);
36300 arg3 = &temp3;
36301 res3 = SWIG_AddTmpMask(ecode);
36302 }
36303 {
36304 PyThreadState* __tstate = wxPyBeginAllowThreads();
36305 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36306 wxPyEndAllowThreads(__tstate);
36307 if (PyErr_Occurred()) SWIG_fail;
36308 }
36309 resultobj = SWIG_Py_Void();
36310 if (SWIG_IsTmpObj(res2)) {
36311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36312 } else {
36313 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36315 }
36316 if (SWIG_IsTmpObj(res3)) {
36317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36318 } else {
36319 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36321 }
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36329 PyObject *resultobj = 0;
36330 wxWindow *arg1 = (wxWindow *) 0 ;
36331 wxPoint *arg2 = 0 ;
36332 wxPoint result;
36333 void *argp1 = 0 ;
36334 int res1 = 0 ;
36335 wxPoint temp2 ;
36336 PyObject * obj0 = 0 ;
36337 PyObject * obj1 = 0 ;
36338 char * kwnames[] = {
36339 (char *) "self",(char *) "pt", NULL
36340 };
36341
36342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36344 if (!SWIG_IsOK(res1)) {
36345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36346 }
36347 arg1 = reinterpret_cast< wxWindow * >(argp1);
36348 {
36349 arg2 = &temp2;
36350 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36351 }
36352 {
36353 PyThreadState* __tstate = wxPyBeginAllowThreads();
36354 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36355 wxPyEndAllowThreads(__tstate);
36356 if (PyErr_Occurred()) SWIG_fail;
36357 }
36358 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36359 return resultobj;
36360 fail:
36361 return NULL;
36362 }
36363
36364
36365 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36366 PyObject *resultobj = 0;
36367 wxWindow *arg1 = (wxWindow *) 0 ;
36368 wxPoint *arg2 = 0 ;
36369 wxPoint result;
36370 void *argp1 = 0 ;
36371 int res1 = 0 ;
36372 wxPoint temp2 ;
36373 PyObject * obj0 = 0 ;
36374 PyObject * obj1 = 0 ;
36375 char * kwnames[] = {
36376 (char *) "self",(char *) "pt", NULL
36377 };
36378
36379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36381 if (!SWIG_IsOK(res1)) {
36382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36383 }
36384 arg1 = reinterpret_cast< wxWindow * >(argp1);
36385 {
36386 arg2 = &temp2;
36387 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36388 }
36389 {
36390 PyThreadState* __tstate = wxPyBeginAllowThreads();
36391 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36392 wxPyEndAllowThreads(__tstate);
36393 if (PyErr_Occurred()) SWIG_fail;
36394 }
36395 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36396 return resultobj;
36397 fail:
36398 return NULL;
36399 }
36400
36401
36402 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36403 PyObject *resultobj = 0;
36404 wxWindow *arg1 = (wxWindow *) 0 ;
36405 int arg2 ;
36406 int arg3 ;
36407 wxHitTest result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 int val2 ;
36411 int ecode2 = 0 ;
36412 int val3 ;
36413 int ecode3 = 0 ;
36414 PyObject * obj0 = 0 ;
36415 PyObject * obj1 = 0 ;
36416 PyObject * obj2 = 0 ;
36417 char * kwnames[] = {
36418 (char *) "self",(char *) "x",(char *) "y", NULL
36419 };
36420
36421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36423 if (!SWIG_IsOK(res1)) {
36424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36425 }
36426 arg1 = reinterpret_cast< wxWindow * >(argp1);
36427 ecode2 = SWIG_AsVal_int(obj1, &val2);
36428 if (!SWIG_IsOK(ecode2)) {
36429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36430 }
36431 arg2 = static_cast< int >(val2);
36432 ecode3 = SWIG_AsVal_int(obj2, &val3);
36433 if (!SWIG_IsOK(ecode3)) {
36434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36435 }
36436 arg3 = static_cast< int >(val3);
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 resultobj = SWIG_From_int(static_cast< int >(result));
36444 return resultobj;
36445 fail:
36446 return NULL;
36447 }
36448
36449
36450 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36451 PyObject *resultobj = 0;
36452 wxWindow *arg1 = (wxWindow *) 0 ;
36453 wxPoint *arg2 = 0 ;
36454 wxHitTest result;
36455 void *argp1 = 0 ;
36456 int res1 = 0 ;
36457 wxPoint temp2 ;
36458 PyObject * obj0 = 0 ;
36459 PyObject * obj1 = 0 ;
36460 char * kwnames[] = {
36461 (char *) "self",(char *) "pt", NULL
36462 };
36463
36464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36466 if (!SWIG_IsOK(res1)) {
36467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36468 }
36469 arg1 = reinterpret_cast< wxWindow * >(argp1);
36470 {
36471 arg2 = &temp2;
36472 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36473 }
36474 {
36475 PyThreadState* __tstate = wxPyBeginAllowThreads();
36476 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36477 wxPyEndAllowThreads(__tstate);
36478 if (PyErr_Occurred()) SWIG_fail;
36479 }
36480 resultobj = SWIG_From_int(static_cast< int >(result));
36481 return resultobj;
36482 fail:
36483 return NULL;
36484 }
36485
36486
36487 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36488 PyObject *resultobj = 0;
36489 wxWindow *arg1 = (wxWindow *) 0 ;
36490 long arg2 ;
36491 wxBorder result;
36492 void *argp1 = 0 ;
36493 int res1 = 0 ;
36494 long val2 ;
36495 int ecode2 = 0 ;
36496
36497 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36499 if (!SWIG_IsOK(res1)) {
36500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36501 }
36502 arg1 = reinterpret_cast< wxWindow * >(argp1);
36503 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36504 if (!SWIG_IsOK(ecode2)) {
36505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36506 }
36507 arg2 = static_cast< long >(val2);
36508 {
36509 PyThreadState* __tstate = wxPyBeginAllowThreads();
36510 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36511 wxPyEndAllowThreads(__tstate);
36512 if (PyErr_Occurred()) SWIG_fail;
36513 }
36514 resultobj = SWIG_From_int(static_cast< int >(result));
36515 return resultobj;
36516 fail:
36517 return NULL;
36518 }
36519
36520
36521 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36522 PyObject *resultobj = 0;
36523 wxWindow *arg1 = (wxWindow *) 0 ;
36524 wxBorder result;
36525 void *argp1 = 0 ;
36526 int res1 = 0 ;
36527
36528 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36530 if (!SWIG_IsOK(res1)) {
36531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36532 }
36533 arg1 = reinterpret_cast< wxWindow * >(argp1);
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 resultobj = SWIG_From_int(static_cast< int >(result));
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36548 int argc;
36549 PyObject *argv[3];
36550
36551 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36552 --argc;
36553 if (argc == 1) {
36554 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36555 }
36556 if (argc == 2) {
36557 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36558 }
36559
36560 fail:
36561 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36562 return NULL;
36563 }
36564
36565
36566 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36567 PyObject *resultobj = 0;
36568 wxWindow *arg1 = (wxWindow *) 0 ;
36569 long arg2 = (long) wxUPDATE_UI_NONE ;
36570 void *argp1 = 0 ;
36571 int res1 = 0 ;
36572 long val2 ;
36573 int ecode2 = 0 ;
36574 PyObject * obj0 = 0 ;
36575 PyObject * obj1 = 0 ;
36576 char * kwnames[] = {
36577 (char *) "self",(char *) "flags", NULL
36578 };
36579
36580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36582 if (!SWIG_IsOK(res1)) {
36583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36584 }
36585 arg1 = reinterpret_cast< wxWindow * >(argp1);
36586 if (obj1) {
36587 ecode2 = SWIG_AsVal_long(obj1, &val2);
36588 if (!SWIG_IsOK(ecode2)) {
36589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36590 }
36591 arg2 = static_cast< long >(val2);
36592 }
36593 {
36594 PyThreadState* __tstate = wxPyBeginAllowThreads();
36595 (arg1)->UpdateWindowUI(arg2);
36596 wxPyEndAllowThreads(__tstate);
36597 if (PyErr_Occurred()) SWIG_fail;
36598 }
36599 resultobj = SWIG_Py_Void();
36600 return resultobj;
36601 fail:
36602 return NULL;
36603 }
36604
36605
36606 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36607 PyObject *resultobj = 0;
36608 wxWindow *arg1 = (wxWindow *) 0 ;
36609 wxMenu *arg2 = (wxMenu *) 0 ;
36610 int arg3 = (int) -1 ;
36611 int arg4 = (int) -1 ;
36612 bool result;
36613 void *argp1 = 0 ;
36614 int res1 = 0 ;
36615 void *argp2 = 0 ;
36616 int res2 = 0 ;
36617 int val3 ;
36618 int ecode3 = 0 ;
36619 int val4 ;
36620 int ecode4 = 0 ;
36621 PyObject * obj0 = 0 ;
36622 PyObject * obj1 = 0 ;
36623 PyObject * obj2 = 0 ;
36624 PyObject * obj3 = 0 ;
36625 char * kwnames[] = {
36626 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36627 };
36628
36629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36631 if (!SWIG_IsOK(res1)) {
36632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36633 }
36634 arg1 = reinterpret_cast< wxWindow * >(argp1);
36635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36636 if (!SWIG_IsOK(res2)) {
36637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36638 }
36639 arg2 = reinterpret_cast< wxMenu * >(argp2);
36640 if (obj2) {
36641 ecode3 = SWIG_AsVal_int(obj2, &val3);
36642 if (!SWIG_IsOK(ecode3)) {
36643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36644 }
36645 arg3 = static_cast< int >(val3);
36646 }
36647 if (obj3) {
36648 ecode4 = SWIG_AsVal_int(obj3, &val4);
36649 if (!SWIG_IsOK(ecode4)) {
36650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36651 }
36652 arg4 = static_cast< int >(val4);
36653 }
36654 {
36655 PyThreadState* __tstate = wxPyBeginAllowThreads();
36656 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36657 wxPyEndAllowThreads(__tstate);
36658 if (PyErr_Occurred()) SWIG_fail;
36659 }
36660 {
36661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36662 }
36663 return resultobj;
36664 fail:
36665 return NULL;
36666 }
36667
36668
36669 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36670 PyObject *resultobj = 0;
36671 wxWindow *arg1 = (wxWindow *) 0 ;
36672 wxMenu *arg2 = (wxMenu *) 0 ;
36673 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36674 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36675 bool result;
36676 void *argp1 = 0 ;
36677 int res1 = 0 ;
36678 void *argp2 = 0 ;
36679 int res2 = 0 ;
36680 wxPoint temp3 ;
36681 PyObject * obj0 = 0 ;
36682 PyObject * obj1 = 0 ;
36683 PyObject * obj2 = 0 ;
36684 char * kwnames[] = {
36685 (char *) "self",(char *) "menu",(char *) "pos", NULL
36686 };
36687
36688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36690 if (!SWIG_IsOK(res1)) {
36691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36692 }
36693 arg1 = reinterpret_cast< wxWindow * >(argp1);
36694 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36695 if (!SWIG_IsOK(res2)) {
36696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36697 }
36698 arg2 = reinterpret_cast< wxMenu * >(argp2);
36699 if (obj2) {
36700 {
36701 arg3 = &temp3;
36702 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36703 }
36704 }
36705 {
36706 PyThreadState* __tstate = wxPyBeginAllowThreads();
36707 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36708 wxPyEndAllowThreads(__tstate);
36709 if (PyErr_Occurred()) SWIG_fail;
36710 }
36711 {
36712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36713 }
36714 return resultobj;
36715 fail:
36716 return NULL;
36717 }
36718
36719
36720 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36721 PyObject *resultobj = 0;
36722 wxWindow *arg1 = (wxWindow *) 0 ;
36723 bool result;
36724 void *argp1 = 0 ;
36725 int res1 = 0 ;
36726 PyObject *swig_obj[1] ;
36727
36728 if (!args) SWIG_fail;
36729 swig_obj[0] = args;
36730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36731 if (!SWIG_IsOK(res1)) {
36732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36733 }
36734 arg1 = reinterpret_cast< wxWindow * >(argp1);
36735 {
36736 PyThreadState* __tstate = wxPyBeginAllowThreads();
36737 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36738 wxPyEndAllowThreads(__tstate);
36739 if (PyErr_Occurred()) SWIG_fail;
36740 }
36741 {
36742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36743 }
36744 return resultobj;
36745 fail:
36746 return NULL;
36747 }
36748
36749
36750 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36751 PyObject *resultobj = 0;
36752 wxWindow *arg1 = (wxWindow *) 0 ;
36753 long result;
36754 void *argp1 = 0 ;
36755 int res1 = 0 ;
36756 PyObject *swig_obj[1] ;
36757
36758 if (!args) SWIG_fail;
36759 swig_obj[0] = args;
36760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36761 if (!SWIG_IsOK(res1)) {
36762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36763 }
36764 arg1 = reinterpret_cast< wxWindow * >(argp1);
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 result = (long)wxWindow_GetHandle(arg1);
36768 wxPyEndAllowThreads(__tstate);
36769 if (PyErr_Occurred()) SWIG_fail;
36770 }
36771 resultobj = SWIG_From_long(static_cast< long >(result));
36772 return resultobj;
36773 fail:
36774 return NULL;
36775 }
36776
36777
36778 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36779 PyObject *resultobj = 0;
36780 wxWindow *arg1 = (wxWindow *) 0 ;
36781 long arg2 ;
36782 void *argp1 = 0 ;
36783 int res1 = 0 ;
36784 long val2 ;
36785 int ecode2 = 0 ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char * kwnames[] = {
36789 (char *) "self",(char *) "handle", NULL
36790 };
36791
36792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36796 }
36797 arg1 = reinterpret_cast< wxWindow * >(argp1);
36798 ecode2 = SWIG_AsVal_long(obj1, &val2);
36799 if (!SWIG_IsOK(ecode2)) {
36800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36801 }
36802 arg2 = static_cast< long >(val2);
36803 {
36804 PyThreadState* __tstate = wxPyBeginAllowThreads();
36805 wxWindow_AssociateHandle(arg1,arg2);
36806 wxPyEndAllowThreads(__tstate);
36807 if (PyErr_Occurred()) SWIG_fail;
36808 }
36809 resultobj = SWIG_Py_Void();
36810 return resultobj;
36811 fail:
36812 return NULL;
36813 }
36814
36815
36816 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36817 PyObject *resultobj = 0;
36818 wxWindow *arg1 = (wxWindow *) 0 ;
36819 void *argp1 = 0 ;
36820 int res1 = 0 ;
36821 PyObject *swig_obj[1] ;
36822
36823 if (!args) SWIG_fail;
36824 swig_obj[0] = args;
36825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36826 if (!SWIG_IsOK(res1)) {
36827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36828 }
36829 arg1 = reinterpret_cast< wxWindow * >(argp1);
36830 {
36831 PyThreadState* __tstate = wxPyBeginAllowThreads();
36832 (arg1)->DissociateHandle();
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 resultobj = SWIG_Py_Void();
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36844 PyObject *resultobj = 0;
36845 wxWindow *arg1 = (wxWindow *) 0 ;
36846 wxPaintEvent *arg2 = 0 ;
36847 void *argp1 = 0 ;
36848 int res1 = 0 ;
36849 void *argp2 = 0 ;
36850 int res2 = 0 ;
36851 PyObject * obj0 = 0 ;
36852 PyObject * obj1 = 0 ;
36853 char * kwnames[] = {
36854 (char *) "self",(char *) "event", NULL
36855 };
36856
36857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36859 if (!SWIG_IsOK(res1)) {
36860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36861 }
36862 arg1 = reinterpret_cast< wxWindow * >(argp1);
36863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36864 if (!SWIG_IsOK(res2)) {
36865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36866 }
36867 if (!argp2) {
36868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36869 }
36870 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 (arg1)->OnPaint(*arg2);
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 resultobj = SWIG_Py_Void();
36878 return resultobj;
36879 fail:
36880 return NULL;
36881 }
36882
36883
36884 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36885 PyObject *resultobj = 0;
36886 wxWindow *arg1 = (wxWindow *) 0 ;
36887 int arg2 ;
36888 bool result;
36889 void *argp1 = 0 ;
36890 int res1 = 0 ;
36891 int val2 ;
36892 int ecode2 = 0 ;
36893 PyObject * obj0 = 0 ;
36894 PyObject * obj1 = 0 ;
36895 char * kwnames[] = {
36896 (char *) "self",(char *) "orient", NULL
36897 };
36898
36899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 ecode2 = SWIG_AsVal_int(obj1, &val2);
36906 if (!SWIG_IsOK(ecode2)) {
36907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36908 }
36909 arg2 = static_cast< int >(val2);
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 {
36917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36918 }
36919 return resultobj;
36920 fail:
36921 return NULL;
36922 }
36923
36924
36925 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36926 PyObject *resultobj = 0;
36927 wxWindow *arg1 = (wxWindow *) 0 ;
36928 int arg2 ;
36929 int arg3 ;
36930 int arg4 ;
36931 int arg5 ;
36932 bool arg6 = (bool) true ;
36933 void *argp1 = 0 ;
36934 int res1 = 0 ;
36935 int val2 ;
36936 int ecode2 = 0 ;
36937 int val3 ;
36938 int ecode3 = 0 ;
36939 int val4 ;
36940 int ecode4 = 0 ;
36941 int val5 ;
36942 int ecode5 = 0 ;
36943 bool val6 ;
36944 int ecode6 = 0 ;
36945 PyObject * obj0 = 0 ;
36946 PyObject * obj1 = 0 ;
36947 PyObject * obj2 = 0 ;
36948 PyObject * obj3 = 0 ;
36949 PyObject * obj4 = 0 ;
36950 PyObject * obj5 = 0 ;
36951 char * kwnames[] = {
36952 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36953 };
36954
36955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36957 if (!SWIG_IsOK(res1)) {
36958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36959 }
36960 arg1 = reinterpret_cast< wxWindow * >(argp1);
36961 ecode2 = SWIG_AsVal_int(obj1, &val2);
36962 if (!SWIG_IsOK(ecode2)) {
36963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36964 }
36965 arg2 = static_cast< int >(val2);
36966 ecode3 = SWIG_AsVal_int(obj2, &val3);
36967 if (!SWIG_IsOK(ecode3)) {
36968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36969 }
36970 arg3 = static_cast< int >(val3);
36971 ecode4 = SWIG_AsVal_int(obj3, &val4);
36972 if (!SWIG_IsOK(ecode4)) {
36973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36974 }
36975 arg4 = static_cast< int >(val4);
36976 ecode5 = SWIG_AsVal_int(obj4, &val5);
36977 if (!SWIG_IsOK(ecode5)) {
36978 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36979 }
36980 arg5 = static_cast< int >(val5);
36981 if (obj5) {
36982 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36983 if (!SWIG_IsOK(ecode6)) {
36984 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36985 }
36986 arg6 = static_cast< bool >(val6);
36987 }
36988 {
36989 PyThreadState* __tstate = wxPyBeginAllowThreads();
36990 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36991 wxPyEndAllowThreads(__tstate);
36992 if (PyErr_Occurred()) SWIG_fail;
36993 }
36994 resultobj = SWIG_Py_Void();
36995 return resultobj;
36996 fail:
36997 return NULL;
36998 }
36999
37000
37001 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37002 PyObject *resultobj = 0;
37003 wxWindow *arg1 = (wxWindow *) 0 ;
37004 int arg2 ;
37005 int arg3 ;
37006 bool arg4 = (bool) true ;
37007 void *argp1 = 0 ;
37008 int res1 = 0 ;
37009 int val2 ;
37010 int ecode2 = 0 ;
37011 int val3 ;
37012 int ecode3 = 0 ;
37013 bool val4 ;
37014 int ecode4 = 0 ;
37015 PyObject * obj0 = 0 ;
37016 PyObject * obj1 = 0 ;
37017 PyObject * obj2 = 0 ;
37018 PyObject * obj3 = 0 ;
37019 char * kwnames[] = {
37020 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37021 };
37022
37023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37025 if (!SWIG_IsOK(res1)) {
37026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37027 }
37028 arg1 = reinterpret_cast< wxWindow * >(argp1);
37029 ecode2 = SWIG_AsVal_int(obj1, &val2);
37030 if (!SWIG_IsOK(ecode2)) {
37031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37032 }
37033 arg2 = static_cast< int >(val2);
37034 ecode3 = SWIG_AsVal_int(obj2, &val3);
37035 if (!SWIG_IsOK(ecode3)) {
37036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37037 }
37038 arg3 = static_cast< int >(val3);
37039 if (obj3) {
37040 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37041 if (!SWIG_IsOK(ecode4)) {
37042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37043 }
37044 arg4 = static_cast< bool >(val4);
37045 }
37046 {
37047 PyThreadState* __tstate = wxPyBeginAllowThreads();
37048 (arg1)->SetScrollPos(arg2,arg3,arg4);
37049 wxPyEndAllowThreads(__tstate);
37050 if (PyErr_Occurred()) SWIG_fail;
37051 }
37052 resultobj = SWIG_Py_Void();
37053 return resultobj;
37054 fail:
37055 return NULL;
37056 }
37057
37058
37059 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37060 PyObject *resultobj = 0;
37061 wxWindow *arg1 = (wxWindow *) 0 ;
37062 int arg2 ;
37063 int result;
37064 void *argp1 = 0 ;
37065 int res1 = 0 ;
37066 int val2 ;
37067 int ecode2 = 0 ;
37068 PyObject * obj0 = 0 ;
37069 PyObject * obj1 = 0 ;
37070 char * kwnames[] = {
37071 (char *) "self",(char *) "orientation", NULL
37072 };
37073
37074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37076 if (!SWIG_IsOK(res1)) {
37077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37078 }
37079 arg1 = reinterpret_cast< wxWindow * >(argp1);
37080 ecode2 = SWIG_AsVal_int(obj1, &val2);
37081 if (!SWIG_IsOK(ecode2)) {
37082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37083 }
37084 arg2 = static_cast< int >(val2);
37085 {
37086 PyThreadState* __tstate = wxPyBeginAllowThreads();
37087 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37088 wxPyEndAllowThreads(__tstate);
37089 if (PyErr_Occurred()) SWIG_fail;
37090 }
37091 resultobj = SWIG_From_int(static_cast< int >(result));
37092 return resultobj;
37093 fail:
37094 return NULL;
37095 }
37096
37097
37098 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37099 PyObject *resultobj = 0;
37100 wxWindow *arg1 = (wxWindow *) 0 ;
37101 int arg2 ;
37102 int result;
37103 void *argp1 = 0 ;
37104 int res1 = 0 ;
37105 int val2 ;
37106 int ecode2 = 0 ;
37107 PyObject * obj0 = 0 ;
37108 PyObject * obj1 = 0 ;
37109 char * kwnames[] = {
37110 (char *) "self",(char *) "orientation", NULL
37111 };
37112
37113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37115 if (!SWIG_IsOK(res1)) {
37116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37117 }
37118 arg1 = reinterpret_cast< wxWindow * >(argp1);
37119 ecode2 = SWIG_AsVal_int(obj1, &val2);
37120 if (!SWIG_IsOK(ecode2)) {
37121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37122 }
37123 arg2 = static_cast< int >(val2);
37124 {
37125 PyThreadState* __tstate = wxPyBeginAllowThreads();
37126 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37127 wxPyEndAllowThreads(__tstate);
37128 if (PyErr_Occurred()) SWIG_fail;
37129 }
37130 resultobj = SWIG_From_int(static_cast< int >(result));
37131 return resultobj;
37132 fail:
37133 return NULL;
37134 }
37135
37136
37137 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37138 PyObject *resultobj = 0;
37139 wxWindow *arg1 = (wxWindow *) 0 ;
37140 int arg2 ;
37141 int result;
37142 void *argp1 = 0 ;
37143 int res1 = 0 ;
37144 int val2 ;
37145 int ecode2 = 0 ;
37146 PyObject * obj0 = 0 ;
37147 PyObject * obj1 = 0 ;
37148 char * kwnames[] = {
37149 (char *) "self",(char *) "orientation", NULL
37150 };
37151
37152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37154 if (!SWIG_IsOK(res1)) {
37155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37156 }
37157 arg1 = reinterpret_cast< wxWindow * >(argp1);
37158 ecode2 = SWIG_AsVal_int(obj1, &val2);
37159 if (!SWIG_IsOK(ecode2)) {
37160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37161 }
37162 arg2 = static_cast< int >(val2);
37163 {
37164 PyThreadState* __tstate = wxPyBeginAllowThreads();
37165 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37166 wxPyEndAllowThreads(__tstate);
37167 if (PyErr_Occurred()) SWIG_fail;
37168 }
37169 resultobj = SWIG_From_int(static_cast< int >(result));
37170 return resultobj;
37171 fail:
37172 return NULL;
37173 }
37174
37175
37176 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37177 PyObject *resultobj = 0;
37178 wxWindow *arg1 = (wxWindow *) 0 ;
37179 int arg2 ;
37180 int arg3 ;
37181 wxRect *arg4 = (wxRect *) NULL ;
37182 void *argp1 = 0 ;
37183 int res1 = 0 ;
37184 int val2 ;
37185 int ecode2 = 0 ;
37186 int val3 ;
37187 int ecode3 = 0 ;
37188 void *argp4 = 0 ;
37189 int res4 = 0 ;
37190 PyObject * obj0 = 0 ;
37191 PyObject * obj1 = 0 ;
37192 PyObject * obj2 = 0 ;
37193 PyObject * obj3 = 0 ;
37194 char * kwnames[] = {
37195 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37196 };
37197
37198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37200 if (!SWIG_IsOK(res1)) {
37201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37202 }
37203 arg1 = reinterpret_cast< wxWindow * >(argp1);
37204 ecode2 = SWIG_AsVal_int(obj1, &val2);
37205 if (!SWIG_IsOK(ecode2)) {
37206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37207 }
37208 arg2 = static_cast< int >(val2);
37209 ecode3 = SWIG_AsVal_int(obj2, &val3);
37210 if (!SWIG_IsOK(ecode3)) {
37211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37212 }
37213 arg3 = static_cast< int >(val3);
37214 if (obj3) {
37215 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37216 if (!SWIG_IsOK(res4)) {
37217 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37218 }
37219 arg4 = reinterpret_cast< wxRect * >(argp4);
37220 }
37221 {
37222 PyThreadState* __tstate = wxPyBeginAllowThreads();
37223 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37224 wxPyEndAllowThreads(__tstate);
37225 if (PyErr_Occurred()) SWIG_fail;
37226 }
37227 resultobj = SWIG_Py_Void();
37228 return resultobj;
37229 fail:
37230 return NULL;
37231 }
37232
37233
37234 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37235 PyObject *resultobj = 0;
37236 wxWindow *arg1 = (wxWindow *) 0 ;
37237 int arg2 ;
37238 bool result;
37239 void *argp1 = 0 ;
37240 int res1 = 0 ;
37241 int val2 ;
37242 int ecode2 = 0 ;
37243 PyObject * obj0 = 0 ;
37244 PyObject * obj1 = 0 ;
37245 char * kwnames[] = {
37246 (char *) "self",(char *) "lines", NULL
37247 };
37248
37249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37251 if (!SWIG_IsOK(res1)) {
37252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37253 }
37254 arg1 = reinterpret_cast< wxWindow * >(argp1);
37255 ecode2 = SWIG_AsVal_int(obj1, &val2);
37256 if (!SWIG_IsOK(ecode2)) {
37257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37258 }
37259 arg2 = static_cast< int >(val2);
37260 {
37261 PyThreadState* __tstate = wxPyBeginAllowThreads();
37262 result = (bool)(arg1)->ScrollLines(arg2);
37263 wxPyEndAllowThreads(__tstate);
37264 if (PyErr_Occurred()) SWIG_fail;
37265 }
37266 {
37267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37268 }
37269 return resultobj;
37270 fail:
37271 return NULL;
37272 }
37273
37274
37275 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37276 PyObject *resultobj = 0;
37277 wxWindow *arg1 = (wxWindow *) 0 ;
37278 int arg2 ;
37279 bool result;
37280 void *argp1 = 0 ;
37281 int res1 = 0 ;
37282 int val2 ;
37283 int ecode2 = 0 ;
37284 PyObject * obj0 = 0 ;
37285 PyObject * obj1 = 0 ;
37286 char * kwnames[] = {
37287 (char *) "self",(char *) "pages", NULL
37288 };
37289
37290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37292 if (!SWIG_IsOK(res1)) {
37293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37294 }
37295 arg1 = reinterpret_cast< wxWindow * >(argp1);
37296 ecode2 = SWIG_AsVal_int(obj1, &val2);
37297 if (!SWIG_IsOK(ecode2)) {
37298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37299 }
37300 arg2 = static_cast< int >(val2);
37301 {
37302 PyThreadState* __tstate = wxPyBeginAllowThreads();
37303 result = (bool)(arg1)->ScrollPages(arg2);
37304 wxPyEndAllowThreads(__tstate);
37305 if (PyErr_Occurred()) SWIG_fail;
37306 }
37307 {
37308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37309 }
37310 return resultobj;
37311 fail:
37312 return NULL;
37313 }
37314
37315
37316 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37317 PyObject *resultobj = 0;
37318 wxWindow *arg1 = (wxWindow *) 0 ;
37319 bool result;
37320 void *argp1 = 0 ;
37321 int res1 = 0 ;
37322 PyObject *swig_obj[1] ;
37323
37324 if (!args) SWIG_fail;
37325 swig_obj[0] = args;
37326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37327 if (!SWIG_IsOK(res1)) {
37328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37329 }
37330 arg1 = reinterpret_cast< wxWindow * >(argp1);
37331 {
37332 PyThreadState* __tstate = wxPyBeginAllowThreads();
37333 result = (bool)(arg1)->LineUp();
37334 wxPyEndAllowThreads(__tstate);
37335 if (PyErr_Occurred()) SWIG_fail;
37336 }
37337 {
37338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37339 }
37340 return resultobj;
37341 fail:
37342 return NULL;
37343 }
37344
37345
37346 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37347 PyObject *resultobj = 0;
37348 wxWindow *arg1 = (wxWindow *) 0 ;
37349 bool result;
37350 void *argp1 = 0 ;
37351 int res1 = 0 ;
37352 PyObject *swig_obj[1] ;
37353
37354 if (!args) SWIG_fail;
37355 swig_obj[0] = args;
37356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37357 if (!SWIG_IsOK(res1)) {
37358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37359 }
37360 arg1 = reinterpret_cast< wxWindow * >(argp1);
37361 {
37362 PyThreadState* __tstate = wxPyBeginAllowThreads();
37363 result = (bool)(arg1)->LineDown();
37364 wxPyEndAllowThreads(__tstate);
37365 if (PyErr_Occurred()) SWIG_fail;
37366 }
37367 {
37368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37369 }
37370 return resultobj;
37371 fail:
37372 return NULL;
37373 }
37374
37375
37376 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37377 PyObject *resultobj = 0;
37378 wxWindow *arg1 = (wxWindow *) 0 ;
37379 bool result;
37380 void *argp1 = 0 ;
37381 int res1 = 0 ;
37382 PyObject *swig_obj[1] ;
37383
37384 if (!args) SWIG_fail;
37385 swig_obj[0] = args;
37386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37387 if (!SWIG_IsOK(res1)) {
37388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37389 }
37390 arg1 = reinterpret_cast< wxWindow * >(argp1);
37391 {
37392 PyThreadState* __tstate = wxPyBeginAllowThreads();
37393 result = (bool)(arg1)->PageUp();
37394 wxPyEndAllowThreads(__tstate);
37395 if (PyErr_Occurred()) SWIG_fail;
37396 }
37397 {
37398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37399 }
37400 return resultobj;
37401 fail:
37402 return NULL;
37403 }
37404
37405
37406 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37407 PyObject *resultobj = 0;
37408 wxWindow *arg1 = (wxWindow *) 0 ;
37409 bool result;
37410 void *argp1 = 0 ;
37411 int res1 = 0 ;
37412 PyObject *swig_obj[1] ;
37413
37414 if (!args) SWIG_fail;
37415 swig_obj[0] = args;
37416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37417 if (!SWIG_IsOK(res1)) {
37418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37419 }
37420 arg1 = reinterpret_cast< wxWindow * >(argp1);
37421 {
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 result = (bool)(arg1)->PageDown();
37424 wxPyEndAllowThreads(__tstate);
37425 if (PyErr_Occurred()) SWIG_fail;
37426 }
37427 {
37428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37429 }
37430 return resultobj;
37431 fail:
37432 return NULL;
37433 }
37434
37435
37436 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37437 PyObject *resultobj = 0;
37438 wxWindow *arg1 = (wxWindow *) 0 ;
37439 wxString *arg2 = 0 ;
37440 void *argp1 = 0 ;
37441 int res1 = 0 ;
37442 bool temp2 = false ;
37443 PyObject * obj0 = 0 ;
37444 PyObject * obj1 = 0 ;
37445 char * kwnames[] = {
37446 (char *) "self",(char *) "text", NULL
37447 };
37448
37449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 {
37456 arg2 = wxString_in_helper(obj1);
37457 if (arg2 == NULL) SWIG_fail;
37458 temp2 = true;
37459 }
37460 {
37461 PyThreadState* __tstate = wxPyBeginAllowThreads();
37462 (arg1)->SetHelpText((wxString const &)*arg2);
37463 wxPyEndAllowThreads(__tstate);
37464 if (PyErr_Occurred()) SWIG_fail;
37465 }
37466 resultobj = SWIG_Py_Void();
37467 {
37468 if (temp2)
37469 delete arg2;
37470 }
37471 return resultobj;
37472 fail:
37473 {
37474 if (temp2)
37475 delete arg2;
37476 }
37477 return NULL;
37478 }
37479
37480
37481 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37482 PyObject *resultobj = 0;
37483 wxWindow *arg1 = (wxWindow *) 0 ;
37484 wxString *arg2 = 0 ;
37485 void *argp1 = 0 ;
37486 int res1 = 0 ;
37487 bool temp2 = false ;
37488 PyObject * obj0 = 0 ;
37489 PyObject * obj1 = 0 ;
37490 char * kwnames[] = {
37491 (char *) "self",(char *) "text", NULL
37492 };
37493
37494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37496 if (!SWIG_IsOK(res1)) {
37497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37498 }
37499 arg1 = reinterpret_cast< wxWindow * >(argp1);
37500 {
37501 arg2 = wxString_in_helper(obj1);
37502 if (arg2 == NULL) SWIG_fail;
37503 temp2 = true;
37504 }
37505 {
37506 PyThreadState* __tstate = wxPyBeginAllowThreads();
37507 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37508 wxPyEndAllowThreads(__tstate);
37509 if (PyErr_Occurred()) SWIG_fail;
37510 }
37511 resultobj = SWIG_Py_Void();
37512 {
37513 if (temp2)
37514 delete arg2;
37515 }
37516 return resultobj;
37517 fail:
37518 {
37519 if (temp2)
37520 delete arg2;
37521 }
37522 return NULL;
37523 }
37524
37525
37526 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37527 PyObject *resultobj = 0;
37528 wxWindow *arg1 = (wxWindow *) 0 ;
37529 wxPoint *arg2 = 0 ;
37530 wxHelpEvent::Origin arg3 ;
37531 wxString result;
37532 void *argp1 = 0 ;
37533 int res1 = 0 ;
37534 wxPoint temp2 ;
37535 void *argp3 ;
37536 int res3 = 0 ;
37537 PyObject * obj0 = 0 ;
37538 PyObject * obj1 = 0 ;
37539 PyObject * obj2 = 0 ;
37540 char * kwnames[] = {
37541 (char *) "self",(char *) "pt",(char *) "origin", NULL
37542 };
37543
37544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37546 if (!SWIG_IsOK(res1)) {
37547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37548 }
37549 arg1 = reinterpret_cast< wxWindow * >(argp1);
37550 {
37551 arg2 = &temp2;
37552 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37553 }
37554 {
37555 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37556 if (!SWIG_IsOK(res3)) {
37557 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37558 }
37559 if (!argp3) {
37560 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37561 } else {
37562 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37563 arg3 = *temp;
37564 if (SWIG_IsNewObj(res3)) delete temp;
37565 }
37566 }
37567 {
37568 PyThreadState* __tstate = wxPyBeginAllowThreads();
37569 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37570 wxPyEndAllowThreads(__tstate);
37571 if (PyErr_Occurred()) SWIG_fail;
37572 }
37573 {
37574 #if wxUSE_UNICODE
37575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37576 #else
37577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37578 #endif
37579 }
37580 return resultobj;
37581 fail:
37582 return NULL;
37583 }
37584
37585
37586 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37587 PyObject *resultobj = 0;
37588 wxWindow *arg1 = (wxWindow *) 0 ;
37589 wxString result;
37590 void *argp1 = 0 ;
37591 int res1 = 0 ;
37592 PyObject *swig_obj[1] ;
37593
37594 if (!args) SWIG_fail;
37595 swig_obj[0] = args;
37596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37597 if (!SWIG_IsOK(res1)) {
37598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37599 }
37600 arg1 = reinterpret_cast< wxWindow * >(argp1);
37601 {
37602 PyThreadState* __tstate = wxPyBeginAllowThreads();
37603 result = ((wxWindow const *)arg1)->GetHelpText();
37604 wxPyEndAllowThreads(__tstate);
37605 if (PyErr_Occurred()) SWIG_fail;
37606 }
37607 {
37608 #if wxUSE_UNICODE
37609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37610 #else
37611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37612 #endif
37613 }
37614 return resultobj;
37615 fail:
37616 return NULL;
37617 }
37618
37619
37620 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37621 PyObject *resultobj = 0;
37622 wxWindow *arg1 = (wxWindow *) 0 ;
37623 wxString *arg2 = 0 ;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 bool temp2 = false ;
37627 PyObject * obj0 = 0 ;
37628 PyObject * obj1 = 0 ;
37629 char * kwnames[] = {
37630 (char *) "self",(char *) "tip", NULL
37631 };
37632
37633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37635 if (!SWIG_IsOK(res1)) {
37636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37637 }
37638 arg1 = reinterpret_cast< wxWindow * >(argp1);
37639 {
37640 arg2 = wxString_in_helper(obj1);
37641 if (arg2 == NULL) SWIG_fail;
37642 temp2 = true;
37643 }
37644 {
37645 PyThreadState* __tstate = wxPyBeginAllowThreads();
37646 (arg1)->SetToolTip((wxString const &)*arg2);
37647 wxPyEndAllowThreads(__tstate);
37648 if (PyErr_Occurred()) SWIG_fail;
37649 }
37650 resultobj = SWIG_Py_Void();
37651 {
37652 if (temp2)
37653 delete arg2;
37654 }
37655 return resultobj;
37656 fail:
37657 {
37658 if (temp2)
37659 delete arg2;
37660 }
37661 return NULL;
37662 }
37663
37664
37665 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37666 PyObject *resultobj = 0;
37667 wxWindow *arg1 = (wxWindow *) 0 ;
37668 wxToolTip *arg2 = (wxToolTip *) 0 ;
37669 void *argp1 = 0 ;
37670 int res1 = 0 ;
37671 int res2 = 0 ;
37672 PyObject * obj0 = 0 ;
37673 PyObject * obj1 = 0 ;
37674 char * kwnames[] = {
37675 (char *) "self",(char *) "tip", NULL
37676 };
37677
37678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37680 if (!SWIG_IsOK(res1)) {
37681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37682 }
37683 arg1 = reinterpret_cast< wxWindow * >(argp1);
37684 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37685 if (!SWIG_IsOK(res2)) {
37686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37687 }
37688 {
37689 PyThreadState* __tstate = wxPyBeginAllowThreads();
37690 (arg1)->SetToolTip(arg2);
37691 wxPyEndAllowThreads(__tstate);
37692 if (PyErr_Occurred()) SWIG_fail;
37693 }
37694 resultobj = SWIG_Py_Void();
37695 return resultobj;
37696 fail:
37697 return NULL;
37698 }
37699
37700
37701 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37702 PyObject *resultobj = 0;
37703 wxWindow *arg1 = (wxWindow *) 0 ;
37704 wxToolTip *result = 0 ;
37705 void *argp1 = 0 ;
37706 int res1 = 0 ;
37707 PyObject *swig_obj[1] ;
37708
37709 if (!args) SWIG_fail;
37710 swig_obj[0] = args;
37711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37712 if (!SWIG_IsOK(res1)) {
37713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37714 }
37715 arg1 = reinterpret_cast< wxWindow * >(argp1);
37716 {
37717 PyThreadState* __tstate = wxPyBeginAllowThreads();
37718 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37719 wxPyEndAllowThreads(__tstate);
37720 if (PyErr_Occurred()) SWIG_fail;
37721 }
37722 {
37723 resultobj = wxPyMake_wxObject(result, (bool)0);
37724 }
37725 return resultobj;
37726 fail:
37727 return NULL;
37728 }
37729
37730
37731 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37732 PyObject *resultobj = 0;
37733 wxWindow *arg1 = (wxWindow *) 0 ;
37734 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37735 void *argp1 = 0 ;
37736 int res1 = 0 ;
37737 int res2 = 0 ;
37738 PyObject * obj0 = 0 ;
37739 PyObject * obj1 = 0 ;
37740 char * kwnames[] = {
37741 (char *) "self",(char *) "dropTarget", NULL
37742 };
37743
37744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37746 if (!SWIG_IsOK(res1)) {
37747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37748 }
37749 arg1 = reinterpret_cast< wxWindow * >(argp1);
37750 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37751 if (!SWIG_IsOK(res2)) {
37752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37753 }
37754 {
37755 PyThreadState* __tstate = wxPyBeginAllowThreads();
37756 (arg1)->SetDropTarget(arg2);
37757 wxPyEndAllowThreads(__tstate);
37758 if (PyErr_Occurred()) SWIG_fail;
37759 }
37760 resultobj = SWIG_Py_Void();
37761 return resultobj;
37762 fail:
37763 return NULL;
37764 }
37765
37766
37767 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37768 PyObject *resultobj = 0;
37769 wxWindow *arg1 = (wxWindow *) 0 ;
37770 wxPyDropTarget *result = 0 ;
37771 void *argp1 = 0 ;
37772 int res1 = 0 ;
37773 PyObject *swig_obj[1] ;
37774
37775 if (!args) SWIG_fail;
37776 swig_obj[0] = args;
37777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37778 if (!SWIG_IsOK(res1)) {
37779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37780 }
37781 arg1 = reinterpret_cast< wxWindow * >(argp1);
37782 {
37783 PyThreadState* __tstate = wxPyBeginAllowThreads();
37784 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37785 wxPyEndAllowThreads(__tstate);
37786 if (PyErr_Occurred()) SWIG_fail;
37787 }
37788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37789 return resultobj;
37790 fail:
37791 return NULL;
37792 }
37793
37794
37795 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37796 PyObject *resultobj = 0;
37797 wxWindow *arg1 = (wxWindow *) 0 ;
37798 bool arg2 ;
37799 void *argp1 = 0 ;
37800 int res1 = 0 ;
37801 bool val2 ;
37802 int ecode2 = 0 ;
37803 PyObject * obj0 = 0 ;
37804 PyObject * obj1 = 0 ;
37805 char * kwnames[] = {
37806 (char *) "self",(char *) "accept", NULL
37807 };
37808
37809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37811 if (!SWIG_IsOK(res1)) {
37812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37813 }
37814 arg1 = reinterpret_cast< wxWindow * >(argp1);
37815 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37816 if (!SWIG_IsOK(ecode2)) {
37817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37818 }
37819 arg2 = static_cast< bool >(val2);
37820 {
37821 PyThreadState* __tstate = wxPyBeginAllowThreads();
37822 (arg1)->DragAcceptFiles(arg2);
37823 wxPyEndAllowThreads(__tstate);
37824 if (PyErr_Occurred()) SWIG_fail;
37825 }
37826 resultobj = SWIG_Py_Void();
37827 return resultobj;
37828 fail:
37829 return NULL;
37830 }
37831
37832
37833 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37834 PyObject *resultobj = 0;
37835 wxWindow *arg1 = (wxWindow *) 0 ;
37836 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37837 void *argp1 = 0 ;
37838 int res1 = 0 ;
37839 int res2 = 0 ;
37840 PyObject * obj0 = 0 ;
37841 PyObject * obj1 = 0 ;
37842 char * kwnames[] = {
37843 (char *) "self",(char *) "constraints", NULL
37844 };
37845
37846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37848 if (!SWIG_IsOK(res1)) {
37849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37850 }
37851 arg1 = reinterpret_cast< wxWindow * >(argp1);
37852 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37853 if (!SWIG_IsOK(res2)) {
37854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37855 }
37856 {
37857 PyThreadState* __tstate = wxPyBeginAllowThreads();
37858 (arg1)->SetConstraints(arg2);
37859 wxPyEndAllowThreads(__tstate);
37860 if (PyErr_Occurred()) SWIG_fail;
37861 }
37862 resultobj = SWIG_Py_Void();
37863 return resultobj;
37864 fail:
37865 return NULL;
37866 }
37867
37868
37869 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37870 PyObject *resultobj = 0;
37871 wxWindow *arg1 = (wxWindow *) 0 ;
37872 wxLayoutConstraints *result = 0 ;
37873 void *argp1 = 0 ;
37874 int res1 = 0 ;
37875 PyObject *swig_obj[1] ;
37876
37877 if (!args) SWIG_fail;
37878 swig_obj[0] = args;
37879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37880 if (!SWIG_IsOK(res1)) {
37881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37882 }
37883 arg1 = reinterpret_cast< wxWindow * >(argp1);
37884 {
37885 PyThreadState* __tstate = wxPyBeginAllowThreads();
37886 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37887 wxPyEndAllowThreads(__tstate);
37888 if (PyErr_Occurred()) SWIG_fail;
37889 }
37890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37891 return resultobj;
37892 fail:
37893 return NULL;
37894 }
37895
37896
37897 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37898 PyObject *resultobj = 0;
37899 wxWindow *arg1 = (wxWindow *) 0 ;
37900 bool arg2 ;
37901 void *argp1 = 0 ;
37902 int res1 = 0 ;
37903 bool val2 ;
37904 int ecode2 = 0 ;
37905 PyObject * obj0 = 0 ;
37906 PyObject * obj1 = 0 ;
37907 char * kwnames[] = {
37908 (char *) "self",(char *) "autoLayout", NULL
37909 };
37910
37911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37913 if (!SWIG_IsOK(res1)) {
37914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37915 }
37916 arg1 = reinterpret_cast< wxWindow * >(argp1);
37917 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37918 if (!SWIG_IsOK(ecode2)) {
37919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37920 }
37921 arg2 = static_cast< bool >(val2);
37922 {
37923 PyThreadState* __tstate = wxPyBeginAllowThreads();
37924 (arg1)->SetAutoLayout(arg2);
37925 wxPyEndAllowThreads(__tstate);
37926 if (PyErr_Occurred()) SWIG_fail;
37927 }
37928 resultobj = SWIG_Py_Void();
37929 return resultobj;
37930 fail:
37931 return NULL;
37932 }
37933
37934
37935 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37936 PyObject *resultobj = 0;
37937 wxWindow *arg1 = (wxWindow *) 0 ;
37938 bool result;
37939 void *argp1 = 0 ;
37940 int res1 = 0 ;
37941 PyObject *swig_obj[1] ;
37942
37943 if (!args) SWIG_fail;
37944 swig_obj[0] = args;
37945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37946 if (!SWIG_IsOK(res1)) {
37947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37948 }
37949 arg1 = reinterpret_cast< wxWindow * >(argp1);
37950 {
37951 PyThreadState* __tstate = wxPyBeginAllowThreads();
37952 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37953 wxPyEndAllowThreads(__tstate);
37954 if (PyErr_Occurred()) SWIG_fail;
37955 }
37956 {
37957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37958 }
37959 return resultobj;
37960 fail:
37961 return NULL;
37962 }
37963
37964
37965 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37966 PyObject *resultobj = 0;
37967 wxWindow *arg1 = (wxWindow *) 0 ;
37968 bool result;
37969 void *argp1 = 0 ;
37970 int res1 = 0 ;
37971 PyObject *swig_obj[1] ;
37972
37973 if (!args) SWIG_fail;
37974 swig_obj[0] = args;
37975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37976 if (!SWIG_IsOK(res1)) {
37977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37978 }
37979 arg1 = reinterpret_cast< wxWindow * >(argp1);
37980 {
37981 PyThreadState* __tstate = wxPyBeginAllowThreads();
37982 result = (bool)(arg1)->Layout();
37983 wxPyEndAllowThreads(__tstate);
37984 if (PyErr_Occurred()) SWIG_fail;
37985 }
37986 {
37987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37988 }
37989 return resultobj;
37990 fail:
37991 return NULL;
37992 }
37993
37994
37995 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37996 PyObject *resultobj = 0;
37997 wxWindow *arg1 = (wxWindow *) 0 ;
37998 wxSizer *arg2 = (wxSizer *) 0 ;
37999 bool arg3 = (bool) true ;
38000 void *argp1 = 0 ;
38001 int res1 = 0 ;
38002 int res2 = 0 ;
38003 bool val3 ;
38004 int ecode3 = 0 ;
38005 PyObject * obj0 = 0 ;
38006 PyObject * obj1 = 0 ;
38007 PyObject * obj2 = 0 ;
38008 char * kwnames[] = {
38009 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38010 };
38011
38012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38014 if (!SWIG_IsOK(res1)) {
38015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38016 }
38017 arg1 = reinterpret_cast< wxWindow * >(argp1);
38018 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38019 if (!SWIG_IsOK(res2)) {
38020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38021 }
38022 if (obj2) {
38023 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38024 if (!SWIG_IsOK(ecode3)) {
38025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38026 }
38027 arg3 = static_cast< bool >(val3);
38028 }
38029 {
38030 PyThreadState* __tstate = wxPyBeginAllowThreads();
38031 (arg1)->SetSizer(arg2,arg3);
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 resultobj = SWIG_Py_Void();
38036 return resultobj;
38037 fail:
38038 return NULL;
38039 }
38040
38041
38042 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38043 PyObject *resultobj = 0;
38044 wxWindow *arg1 = (wxWindow *) 0 ;
38045 wxSizer *arg2 = (wxSizer *) 0 ;
38046 bool arg3 = (bool) true ;
38047 void *argp1 = 0 ;
38048 int res1 = 0 ;
38049 int res2 = 0 ;
38050 bool val3 ;
38051 int ecode3 = 0 ;
38052 PyObject * obj0 = 0 ;
38053 PyObject * obj1 = 0 ;
38054 PyObject * obj2 = 0 ;
38055 char * kwnames[] = {
38056 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38057 };
38058
38059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38063 }
38064 arg1 = reinterpret_cast< wxWindow * >(argp1);
38065 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38066 if (!SWIG_IsOK(res2)) {
38067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38068 }
38069 if (obj2) {
38070 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38071 if (!SWIG_IsOK(ecode3)) {
38072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38073 }
38074 arg3 = static_cast< bool >(val3);
38075 }
38076 {
38077 PyThreadState* __tstate = wxPyBeginAllowThreads();
38078 (arg1)->SetSizerAndFit(arg2,arg3);
38079 wxPyEndAllowThreads(__tstate);
38080 if (PyErr_Occurred()) SWIG_fail;
38081 }
38082 resultobj = SWIG_Py_Void();
38083 return resultobj;
38084 fail:
38085 return NULL;
38086 }
38087
38088
38089 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38090 PyObject *resultobj = 0;
38091 wxWindow *arg1 = (wxWindow *) 0 ;
38092 wxSizer *result = 0 ;
38093 void *argp1 = 0 ;
38094 int res1 = 0 ;
38095 PyObject *swig_obj[1] ;
38096
38097 if (!args) SWIG_fail;
38098 swig_obj[0] = args;
38099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38100 if (!SWIG_IsOK(res1)) {
38101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38102 }
38103 arg1 = reinterpret_cast< wxWindow * >(argp1);
38104 {
38105 PyThreadState* __tstate = wxPyBeginAllowThreads();
38106 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38107 wxPyEndAllowThreads(__tstate);
38108 if (PyErr_Occurred()) SWIG_fail;
38109 }
38110 {
38111 resultobj = wxPyMake_wxObject(result, (bool)0);
38112 }
38113 return resultobj;
38114 fail:
38115 return NULL;
38116 }
38117
38118
38119 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38120 PyObject *resultobj = 0;
38121 wxWindow *arg1 = (wxWindow *) 0 ;
38122 wxSizer *arg2 = (wxSizer *) 0 ;
38123 void *argp1 = 0 ;
38124 int res1 = 0 ;
38125 void *argp2 = 0 ;
38126 int res2 = 0 ;
38127 PyObject * obj0 = 0 ;
38128 PyObject * obj1 = 0 ;
38129 char * kwnames[] = {
38130 (char *) "self",(char *) "sizer", NULL
38131 };
38132
38133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38135 if (!SWIG_IsOK(res1)) {
38136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38137 }
38138 arg1 = reinterpret_cast< wxWindow * >(argp1);
38139 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38140 if (!SWIG_IsOK(res2)) {
38141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38142 }
38143 arg2 = reinterpret_cast< wxSizer * >(argp2);
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 (arg1)->SetContainingSizer(arg2);
38147 wxPyEndAllowThreads(__tstate);
38148 if (PyErr_Occurred()) SWIG_fail;
38149 }
38150 resultobj = SWIG_Py_Void();
38151 return resultobj;
38152 fail:
38153 return NULL;
38154 }
38155
38156
38157 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38158 PyObject *resultobj = 0;
38159 wxWindow *arg1 = (wxWindow *) 0 ;
38160 wxSizer *result = 0 ;
38161 void *argp1 = 0 ;
38162 int res1 = 0 ;
38163 PyObject *swig_obj[1] ;
38164
38165 if (!args) SWIG_fail;
38166 swig_obj[0] = args;
38167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38168 if (!SWIG_IsOK(res1)) {
38169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38170 }
38171 arg1 = reinterpret_cast< wxWindow * >(argp1);
38172 {
38173 PyThreadState* __tstate = wxPyBeginAllowThreads();
38174 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38175 wxPyEndAllowThreads(__tstate);
38176 if (PyErr_Occurred()) SWIG_fail;
38177 }
38178 {
38179 resultobj = wxPyMake_wxObject(result, (bool)0);
38180 }
38181 return resultobj;
38182 fail:
38183 return NULL;
38184 }
38185
38186
38187 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38188 PyObject *resultobj = 0;
38189 wxWindow *arg1 = (wxWindow *) 0 ;
38190 void *argp1 = 0 ;
38191 int res1 = 0 ;
38192 PyObject *swig_obj[1] ;
38193
38194 if (!args) SWIG_fail;
38195 swig_obj[0] = args;
38196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38197 if (!SWIG_IsOK(res1)) {
38198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38199 }
38200 arg1 = reinterpret_cast< wxWindow * >(argp1);
38201 {
38202 PyThreadState* __tstate = wxPyBeginAllowThreads();
38203 (arg1)->InheritAttributes();
38204 wxPyEndAllowThreads(__tstate);
38205 if (PyErr_Occurred()) SWIG_fail;
38206 }
38207 resultobj = SWIG_Py_Void();
38208 return resultobj;
38209 fail:
38210 return NULL;
38211 }
38212
38213
38214 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38215 PyObject *resultobj = 0;
38216 wxWindow *arg1 = (wxWindow *) 0 ;
38217 bool result;
38218 void *argp1 = 0 ;
38219 int res1 = 0 ;
38220 PyObject *swig_obj[1] ;
38221
38222 if (!args) SWIG_fail;
38223 swig_obj[0] = args;
38224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38225 if (!SWIG_IsOK(res1)) {
38226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38227 }
38228 arg1 = reinterpret_cast< wxWindow * >(argp1);
38229 {
38230 PyThreadState* __tstate = wxPyBeginAllowThreads();
38231 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38232 wxPyEndAllowThreads(__tstate);
38233 if (PyErr_Occurred()) SWIG_fail;
38234 }
38235 {
38236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38237 }
38238 return resultobj;
38239 fail:
38240 return NULL;
38241 }
38242
38243
38244 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38245 PyObject *resultobj = 0;
38246 wxWindow *arg1 = (wxWindow *) 0 ;
38247 bool result;
38248 void *argp1 = 0 ;
38249 int res1 = 0 ;
38250 PyObject *swig_obj[1] ;
38251
38252 if (!args) SWIG_fail;
38253 swig_obj[0] = args;
38254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38255 if (!SWIG_IsOK(res1)) {
38256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38257 }
38258 arg1 = reinterpret_cast< wxWindow * >(argp1);
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 result = (bool)(arg1)->CanSetTransparent();
38262 wxPyEndAllowThreads(__tstate);
38263 if (PyErr_Occurred()) SWIG_fail;
38264 }
38265 {
38266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38267 }
38268 return resultobj;
38269 fail:
38270 return NULL;
38271 }
38272
38273
38274 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38275 PyObject *resultobj = 0;
38276 wxWindow *arg1 = (wxWindow *) 0 ;
38277 byte arg2 ;
38278 bool result;
38279 void *argp1 = 0 ;
38280 int res1 = 0 ;
38281 unsigned char val2 ;
38282 int ecode2 = 0 ;
38283 PyObject * obj0 = 0 ;
38284 PyObject * obj1 = 0 ;
38285 char * kwnames[] = {
38286 (char *) "self",(char *) "alpha", NULL
38287 };
38288
38289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38291 if (!SWIG_IsOK(res1)) {
38292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38293 }
38294 arg1 = reinterpret_cast< wxWindow * >(argp1);
38295 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38296 if (!SWIG_IsOK(ecode2)) {
38297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38298 }
38299 arg2 = static_cast< byte >(val2);
38300 {
38301 PyThreadState* __tstate = wxPyBeginAllowThreads();
38302 result = (bool)(arg1)->SetTransparent(arg2);
38303 wxPyEndAllowThreads(__tstate);
38304 if (PyErr_Occurred()) SWIG_fail;
38305 }
38306 {
38307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38308 }
38309 return resultobj;
38310 fail:
38311 return NULL;
38312 }
38313
38314
38315 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38316 PyObject *obj;
38317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38318 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38319 return SWIG_Py_Void();
38320 }
38321
38322 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38323 return SWIG_Python_InitShadowInstance(args);
38324 }
38325
38326 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38327 PyObject *resultobj = 0;
38328 long arg1 ;
38329 wxWindow *arg2 = (wxWindow *) NULL ;
38330 wxWindow *result = 0 ;
38331 long val1 ;
38332 int ecode1 = 0 ;
38333 void *argp2 = 0 ;
38334 int res2 = 0 ;
38335 PyObject * obj0 = 0 ;
38336 PyObject * obj1 = 0 ;
38337 char * kwnames[] = {
38338 (char *) "id",(char *) "parent", NULL
38339 };
38340
38341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38342 ecode1 = SWIG_AsVal_long(obj0, &val1);
38343 if (!SWIG_IsOK(ecode1)) {
38344 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38345 }
38346 arg1 = static_cast< long >(val1);
38347 if (obj1) {
38348 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38349 if (!SWIG_IsOK(res2)) {
38350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38351 }
38352 arg2 = reinterpret_cast< wxWindow * >(argp2);
38353 }
38354 {
38355 if (!wxPyCheckForApp()) SWIG_fail;
38356 PyThreadState* __tstate = wxPyBeginAllowThreads();
38357 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38358 wxPyEndAllowThreads(__tstate);
38359 if (PyErr_Occurred()) SWIG_fail;
38360 }
38361 {
38362 resultobj = wxPyMake_wxObject(result, 0);
38363 }
38364 return resultobj;
38365 fail:
38366 return NULL;
38367 }
38368
38369
38370 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38371 PyObject *resultobj = 0;
38372 wxString *arg1 = 0 ;
38373 wxWindow *arg2 = (wxWindow *) NULL ;
38374 wxWindow *result = 0 ;
38375 bool temp1 = false ;
38376 void *argp2 = 0 ;
38377 int res2 = 0 ;
38378 PyObject * obj0 = 0 ;
38379 PyObject * obj1 = 0 ;
38380 char * kwnames[] = {
38381 (char *) "name",(char *) "parent", NULL
38382 };
38383
38384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38385 {
38386 arg1 = wxString_in_helper(obj0);
38387 if (arg1 == NULL) SWIG_fail;
38388 temp1 = true;
38389 }
38390 if (obj1) {
38391 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38392 if (!SWIG_IsOK(res2)) {
38393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38394 }
38395 arg2 = reinterpret_cast< wxWindow * >(argp2);
38396 }
38397 {
38398 if (!wxPyCheckForApp()) SWIG_fail;
38399 PyThreadState* __tstate = wxPyBeginAllowThreads();
38400 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38401 wxPyEndAllowThreads(__tstate);
38402 if (PyErr_Occurred()) SWIG_fail;
38403 }
38404 {
38405 resultobj = wxPyMake_wxObject(result, 0);
38406 }
38407 {
38408 if (temp1)
38409 delete arg1;
38410 }
38411 return resultobj;
38412 fail:
38413 {
38414 if (temp1)
38415 delete arg1;
38416 }
38417 return NULL;
38418 }
38419
38420
38421 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38422 PyObject *resultobj = 0;
38423 wxString *arg1 = 0 ;
38424 wxWindow *arg2 = (wxWindow *) NULL ;
38425 wxWindow *result = 0 ;
38426 bool temp1 = false ;
38427 void *argp2 = 0 ;
38428 int res2 = 0 ;
38429 PyObject * obj0 = 0 ;
38430 PyObject * obj1 = 0 ;
38431 char * kwnames[] = {
38432 (char *) "label",(char *) "parent", NULL
38433 };
38434
38435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38436 {
38437 arg1 = wxString_in_helper(obj0);
38438 if (arg1 == NULL) SWIG_fail;
38439 temp1 = true;
38440 }
38441 if (obj1) {
38442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38443 if (!SWIG_IsOK(res2)) {
38444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38445 }
38446 arg2 = reinterpret_cast< wxWindow * >(argp2);
38447 }
38448 {
38449 if (!wxPyCheckForApp()) SWIG_fail;
38450 PyThreadState* __tstate = wxPyBeginAllowThreads();
38451 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38452 wxPyEndAllowThreads(__tstate);
38453 if (PyErr_Occurred()) SWIG_fail;
38454 }
38455 {
38456 resultobj = wxPyMake_wxObject(result, 0);
38457 }
38458 {
38459 if (temp1)
38460 delete arg1;
38461 }
38462 return resultobj;
38463 fail:
38464 {
38465 if (temp1)
38466 delete arg1;
38467 }
38468 return NULL;
38469 }
38470
38471
38472 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38473 PyObject *resultobj = 0;
38474 wxWindow *arg1 = (wxWindow *) 0 ;
38475 unsigned long arg2 ;
38476 wxWindow *result = 0 ;
38477 void *argp1 = 0 ;
38478 int res1 = 0 ;
38479 unsigned long val2 ;
38480 int ecode2 = 0 ;
38481 PyObject * obj0 = 0 ;
38482 PyObject * obj1 = 0 ;
38483 char * kwnames[] = {
38484 (char *) "parent",(char *) "_hWnd", NULL
38485 };
38486
38487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38489 if (!SWIG_IsOK(res1)) {
38490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38491 }
38492 arg1 = reinterpret_cast< wxWindow * >(argp1);
38493 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38494 if (!SWIG_IsOK(ecode2)) {
38495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38496 }
38497 arg2 = static_cast< unsigned long >(val2);
38498 {
38499 PyThreadState* __tstate = wxPyBeginAllowThreads();
38500 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38501 wxPyEndAllowThreads(__tstate);
38502 if (PyErr_Occurred()) SWIG_fail;
38503 }
38504 {
38505 resultobj = wxPyMake_wxObject(result, 0);
38506 }
38507 return resultobj;
38508 fail:
38509 return NULL;
38510 }
38511
38512
38513 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38514 PyObject *resultobj = 0;
38515 PyObject *result = 0 ;
38516
38517 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38518 {
38519 PyThreadState* __tstate = wxPyBeginAllowThreads();
38520 result = (PyObject *)GetTopLevelWindows();
38521 wxPyEndAllowThreads(__tstate);
38522 if (PyErr_Occurred()) SWIG_fail;
38523 }
38524 resultobj = result;
38525 return resultobj;
38526 fail:
38527 return NULL;
38528 }
38529
38530
38531 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38532 PyObject *resultobj = 0;
38533 wxValidator *result = 0 ;
38534
38535 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38536 {
38537 PyThreadState* __tstate = wxPyBeginAllowThreads();
38538 result = (wxValidator *)new wxValidator();
38539 wxPyEndAllowThreads(__tstate);
38540 if (PyErr_Occurred()) SWIG_fail;
38541 }
38542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38543 return resultobj;
38544 fail:
38545 return NULL;
38546 }
38547
38548
38549 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38550 PyObject *resultobj = 0;
38551 wxValidator *arg1 = (wxValidator *) 0 ;
38552 wxValidator *result = 0 ;
38553 void *argp1 = 0 ;
38554 int res1 = 0 ;
38555 PyObject *swig_obj[1] ;
38556
38557 if (!args) SWIG_fail;
38558 swig_obj[0] = args;
38559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38560 if (!SWIG_IsOK(res1)) {
38561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38562 }
38563 arg1 = reinterpret_cast< wxValidator * >(argp1);
38564 {
38565 PyThreadState* __tstate = wxPyBeginAllowThreads();
38566 result = (wxValidator *)(arg1)->Clone();
38567 wxPyEndAllowThreads(__tstate);
38568 if (PyErr_Occurred()) SWIG_fail;
38569 }
38570 {
38571 resultobj = wxPyMake_wxObject(result, 0);
38572 }
38573 return resultobj;
38574 fail:
38575 return NULL;
38576 }
38577
38578
38579 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38580 PyObject *resultobj = 0;
38581 wxValidator *arg1 = (wxValidator *) 0 ;
38582 wxWindow *arg2 = (wxWindow *) 0 ;
38583 bool result;
38584 void *argp1 = 0 ;
38585 int res1 = 0 ;
38586 void *argp2 = 0 ;
38587 int res2 = 0 ;
38588 PyObject * obj0 = 0 ;
38589 PyObject * obj1 = 0 ;
38590 char * kwnames[] = {
38591 (char *) "self",(char *) "parent", NULL
38592 };
38593
38594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38596 if (!SWIG_IsOK(res1)) {
38597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38598 }
38599 arg1 = reinterpret_cast< wxValidator * >(argp1);
38600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38601 if (!SWIG_IsOK(res2)) {
38602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38603 }
38604 arg2 = reinterpret_cast< wxWindow * >(argp2);
38605 {
38606 PyThreadState* __tstate = wxPyBeginAllowThreads();
38607 result = (bool)(arg1)->Validate(arg2);
38608 wxPyEndAllowThreads(__tstate);
38609 if (PyErr_Occurred()) SWIG_fail;
38610 }
38611 {
38612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38613 }
38614 return resultobj;
38615 fail:
38616 return NULL;
38617 }
38618
38619
38620 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38621 PyObject *resultobj = 0;
38622 wxValidator *arg1 = (wxValidator *) 0 ;
38623 bool result;
38624 void *argp1 = 0 ;
38625 int res1 = 0 ;
38626 PyObject *swig_obj[1] ;
38627
38628 if (!args) SWIG_fail;
38629 swig_obj[0] = args;
38630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38631 if (!SWIG_IsOK(res1)) {
38632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38633 }
38634 arg1 = reinterpret_cast< wxValidator * >(argp1);
38635 {
38636 PyThreadState* __tstate = wxPyBeginAllowThreads();
38637 result = (bool)(arg1)->TransferToWindow();
38638 wxPyEndAllowThreads(__tstate);
38639 if (PyErr_Occurred()) SWIG_fail;
38640 }
38641 {
38642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38643 }
38644 return resultobj;
38645 fail:
38646 return NULL;
38647 }
38648
38649
38650 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38651 PyObject *resultobj = 0;
38652 wxValidator *arg1 = (wxValidator *) 0 ;
38653 bool result;
38654 void *argp1 = 0 ;
38655 int res1 = 0 ;
38656 PyObject *swig_obj[1] ;
38657
38658 if (!args) SWIG_fail;
38659 swig_obj[0] = args;
38660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38661 if (!SWIG_IsOK(res1)) {
38662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38663 }
38664 arg1 = reinterpret_cast< wxValidator * >(argp1);
38665 {
38666 PyThreadState* __tstate = wxPyBeginAllowThreads();
38667 result = (bool)(arg1)->TransferFromWindow();
38668 wxPyEndAllowThreads(__tstate);
38669 if (PyErr_Occurred()) SWIG_fail;
38670 }
38671 {
38672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38673 }
38674 return resultobj;
38675 fail:
38676 return NULL;
38677 }
38678
38679
38680 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38681 PyObject *resultobj = 0;
38682 wxValidator *arg1 = (wxValidator *) 0 ;
38683 wxWindow *result = 0 ;
38684 void *argp1 = 0 ;
38685 int res1 = 0 ;
38686 PyObject *swig_obj[1] ;
38687
38688 if (!args) SWIG_fail;
38689 swig_obj[0] = args;
38690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38691 if (!SWIG_IsOK(res1)) {
38692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38693 }
38694 arg1 = reinterpret_cast< wxValidator * >(argp1);
38695 {
38696 PyThreadState* __tstate = wxPyBeginAllowThreads();
38697 result = (wxWindow *)(arg1)->GetWindow();
38698 wxPyEndAllowThreads(__tstate);
38699 if (PyErr_Occurred()) SWIG_fail;
38700 }
38701 {
38702 resultobj = wxPyMake_wxObject(result, 0);
38703 }
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38711 PyObject *resultobj = 0;
38712 wxValidator *arg1 = (wxValidator *) 0 ;
38713 wxWindow *arg2 = (wxWindow *) 0 ;
38714 void *argp1 = 0 ;
38715 int res1 = 0 ;
38716 void *argp2 = 0 ;
38717 int res2 = 0 ;
38718 PyObject * obj0 = 0 ;
38719 PyObject * obj1 = 0 ;
38720 char * kwnames[] = {
38721 (char *) "self",(char *) "window", NULL
38722 };
38723
38724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38726 if (!SWIG_IsOK(res1)) {
38727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38728 }
38729 arg1 = reinterpret_cast< wxValidator * >(argp1);
38730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38731 if (!SWIG_IsOK(res2)) {
38732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38733 }
38734 arg2 = reinterpret_cast< wxWindow * >(argp2);
38735 {
38736 PyThreadState* __tstate = wxPyBeginAllowThreads();
38737 (arg1)->SetWindow(arg2);
38738 wxPyEndAllowThreads(__tstate);
38739 if (PyErr_Occurred()) SWIG_fail;
38740 }
38741 resultobj = SWIG_Py_Void();
38742 return resultobj;
38743 fail:
38744 return NULL;
38745 }
38746
38747
38748 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38749 PyObject *resultobj = 0;
38750 bool result;
38751
38752 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38753 {
38754 PyThreadState* __tstate = wxPyBeginAllowThreads();
38755 result = (bool)wxValidator::IsSilent();
38756 wxPyEndAllowThreads(__tstate);
38757 if (PyErr_Occurred()) SWIG_fail;
38758 }
38759 {
38760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38761 }
38762 return resultobj;
38763 fail:
38764 return NULL;
38765 }
38766
38767
38768 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38769 PyObject *resultobj = 0;
38770 int arg1 = (int) true ;
38771 int val1 ;
38772 int ecode1 = 0 ;
38773 PyObject * obj0 = 0 ;
38774 char * kwnames[] = {
38775 (char *) "doIt", NULL
38776 };
38777
38778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38779 if (obj0) {
38780 ecode1 = SWIG_AsVal_int(obj0, &val1);
38781 if (!SWIG_IsOK(ecode1)) {
38782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38783 }
38784 arg1 = static_cast< int >(val1);
38785 }
38786 {
38787 PyThreadState* __tstate = wxPyBeginAllowThreads();
38788 wxValidator::SetBellOnError(arg1);
38789 wxPyEndAllowThreads(__tstate);
38790 if (PyErr_Occurred()) SWIG_fail;
38791 }
38792 resultobj = SWIG_Py_Void();
38793 return resultobj;
38794 fail:
38795 return NULL;
38796 }
38797
38798
38799 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38800 PyObject *obj;
38801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38802 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38803 return SWIG_Py_Void();
38804 }
38805
38806 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38807 return SWIG_Python_InitShadowInstance(args);
38808 }
38809
38810 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38811 PyObject *resultobj = 0;
38812 wxPyValidator *result = 0 ;
38813
38814 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38815 {
38816 PyThreadState* __tstate = wxPyBeginAllowThreads();
38817 result = (wxPyValidator *)new wxPyValidator();
38818 wxPyEndAllowThreads(__tstate);
38819 if (PyErr_Occurred()) SWIG_fail;
38820 }
38821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38822 return resultobj;
38823 fail:
38824 return NULL;
38825 }
38826
38827
38828 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38829 PyObject *resultobj = 0;
38830 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38831 PyObject *arg2 = (PyObject *) 0 ;
38832 PyObject *arg3 = (PyObject *) 0 ;
38833 int arg4 = (int) true ;
38834 void *argp1 = 0 ;
38835 int res1 = 0 ;
38836 int val4 ;
38837 int ecode4 = 0 ;
38838 PyObject * obj0 = 0 ;
38839 PyObject * obj1 = 0 ;
38840 PyObject * obj2 = 0 ;
38841 PyObject * obj3 = 0 ;
38842 char * kwnames[] = {
38843 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38844 };
38845
38846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38848 if (!SWIG_IsOK(res1)) {
38849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38850 }
38851 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38852 arg2 = obj1;
38853 arg3 = obj2;
38854 if (obj3) {
38855 ecode4 = SWIG_AsVal_int(obj3, &val4);
38856 if (!SWIG_IsOK(ecode4)) {
38857 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38858 }
38859 arg4 = static_cast< int >(val4);
38860 }
38861 {
38862 PyThreadState* __tstate = wxPyBeginAllowThreads();
38863 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38864 wxPyEndAllowThreads(__tstate);
38865 if (PyErr_Occurred()) SWIG_fail;
38866 }
38867 resultobj = SWIG_Py_Void();
38868 return resultobj;
38869 fail:
38870 return NULL;
38871 }
38872
38873
38874 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38875 PyObject *obj;
38876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38877 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38878 return SWIG_Py_Void();
38879 }
38880
38881 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38882 return SWIG_Python_InitShadowInstance(args);
38883 }
38884
38885 SWIGINTERN int DefaultValidator_set(PyObject *) {
38886 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38887 return 1;
38888 }
38889
38890
38891 SWIGINTERN PyObject *DefaultValidator_get(void) {
38892 PyObject *pyobj = 0;
38893
38894 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38895 return pyobj;
38896 }
38897
38898
38899 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38900 PyObject *resultobj = 0;
38901 wxString const &arg1_defvalue = wxPyEmptyString ;
38902 wxString *arg1 = (wxString *) &arg1_defvalue ;
38903 long arg2 = (long) 0 ;
38904 wxMenu *result = 0 ;
38905 bool temp1 = false ;
38906 long val2 ;
38907 int ecode2 = 0 ;
38908 PyObject * obj0 = 0 ;
38909 PyObject * obj1 = 0 ;
38910 char * kwnames[] = {
38911 (char *) "title",(char *) "style", NULL
38912 };
38913
38914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38915 if (obj0) {
38916 {
38917 arg1 = wxString_in_helper(obj0);
38918 if (arg1 == NULL) SWIG_fail;
38919 temp1 = true;
38920 }
38921 }
38922 if (obj1) {
38923 ecode2 = SWIG_AsVal_long(obj1, &val2);
38924 if (!SWIG_IsOK(ecode2)) {
38925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38926 }
38927 arg2 = static_cast< long >(val2);
38928 }
38929 {
38930 if (!wxPyCheckForApp()) SWIG_fail;
38931 PyThreadState* __tstate = wxPyBeginAllowThreads();
38932 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38933 wxPyEndAllowThreads(__tstate);
38934 if (PyErr_Occurred()) SWIG_fail;
38935 }
38936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38937 {
38938 if (temp1)
38939 delete arg1;
38940 }
38941 return resultobj;
38942 fail:
38943 {
38944 if (temp1)
38945 delete arg1;
38946 }
38947 return NULL;
38948 }
38949
38950
38951 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38952 PyObject *resultobj = 0;
38953 wxMenu *arg1 = (wxMenu *) 0 ;
38954 int arg2 ;
38955 wxString const &arg3_defvalue = wxPyEmptyString ;
38956 wxString *arg3 = (wxString *) &arg3_defvalue ;
38957 wxString const &arg4_defvalue = wxPyEmptyString ;
38958 wxString *arg4 = (wxString *) &arg4_defvalue ;
38959 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38960 wxMenuItem *result = 0 ;
38961 void *argp1 = 0 ;
38962 int res1 = 0 ;
38963 int val2 ;
38964 int ecode2 = 0 ;
38965 bool temp3 = false ;
38966 bool temp4 = false ;
38967 int val5 ;
38968 int ecode5 = 0 ;
38969 PyObject * obj0 = 0 ;
38970 PyObject * obj1 = 0 ;
38971 PyObject * obj2 = 0 ;
38972 PyObject * obj3 = 0 ;
38973 PyObject * obj4 = 0 ;
38974 char * kwnames[] = {
38975 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38976 };
38977
38978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38980 if (!SWIG_IsOK(res1)) {
38981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38982 }
38983 arg1 = reinterpret_cast< wxMenu * >(argp1);
38984 ecode2 = SWIG_AsVal_int(obj1, &val2);
38985 if (!SWIG_IsOK(ecode2)) {
38986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38987 }
38988 arg2 = static_cast< int >(val2);
38989 if (obj2) {
38990 {
38991 arg3 = wxString_in_helper(obj2);
38992 if (arg3 == NULL) SWIG_fail;
38993 temp3 = true;
38994 }
38995 }
38996 if (obj3) {
38997 {
38998 arg4 = wxString_in_helper(obj3);
38999 if (arg4 == NULL) SWIG_fail;
39000 temp4 = true;
39001 }
39002 }
39003 if (obj4) {
39004 ecode5 = SWIG_AsVal_int(obj4, &val5);
39005 if (!SWIG_IsOK(ecode5)) {
39006 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39007 }
39008 arg5 = static_cast< wxItemKind >(val5);
39009 }
39010 {
39011 PyThreadState* __tstate = wxPyBeginAllowThreads();
39012 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39013 wxPyEndAllowThreads(__tstate);
39014 if (PyErr_Occurred()) SWIG_fail;
39015 }
39016 {
39017 resultobj = wxPyMake_wxObject(result, (bool)0);
39018 }
39019 {
39020 if (temp3)
39021 delete arg3;
39022 }
39023 {
39024 if (temp4)
39025 delete arg4;
39026 }
39027 return resultobj;
39028 fail:
39029 {
39030 if (temp3)
39031 delete arg3;
39032 }
39033 {
39034 if (temp4)
39035 delete arg4;
39036 }
39037 return NULL;
39038 }
39039
39040
39041 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39042 PyObject *resultobj = 0;
39043 wxMenu *arg1 = (wxMenu *) 0 ;
39044 wxMenuItem *result = 0 ;
39045 void *argp1 = 0 ;
39046 int res1 = 0 ;
39047 PyObject *swig_obj[1] ;
39048
39049 if (!args) SWIG_fail;
39050 swig_obj[0] = args;
39051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39052 if (!SWIG_IsOK(res1)) {
39053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39054 }
39055 arg1 = reinterpret_cast< wxMenu * >(argp1);
39056 {
39057 PyThreadState* __tstate = wxPyBeginAllowThreads();
39058 result = (wxMenuItem *)(arg1)->AppendSeparator();
39059 wxPyEndAllowThreads(__tstate);
39060 if (PyErr_Occurred()) SWIG_fail;
39061 }
39062 {
39063 resultobj = wxPyMake_wxObject(result, (bool)0);
39064 }
39065 return resultobj;
39066 fail:
39067 return NULL;
39068 }
39069
39070
39071 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39072 PyObject *resultobj = 0;
39073 wxMenu *arg1 = (wxMenu *) 0 ;
39074 int arg2 ;
39075 wxString *arg3 = 0 ;
39076 wxString const &arg4_defvalue = wxPyEmptyString ;
39077 wxString *arg4 = (wxString *) &arg4_defvalue ;
39078 wxMenuItem *result = 0 ;
39079 void *argp1 = 0 ;
39080 int res1 = 0 ;
39081 int val2 ;
39082 int ecode2 = 0 ;
39083 bool temp3 = false ;
39084 bool temp4 = false ;
39085 PyObject * obj0 = 0 ;
39086 PyObject * obj1 = 0 ;
39087 PyObject * obj2 = 0 ;
39088 PyObject * obj3 = 0 ;
39089 char * kwnames[] = {
39090 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39091 };
39092
39093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39095 if (!SWIG_IsOK(res1)) {
39096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39097 }
39098 arg1 = reinterpret_cast< wxMenu * >(argp1);
39099 ecode2 = SWIG_AsVal_int(obj1, &val2);
39100 if (!SWIG_IsOK(ecode2)) {
39101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39102 }
39103 arg2 = static_cast< int >(val2);
39104 {
39105 arg3 = wxString_in_helper(obj2);
39106 if (arg3 == NULL) SWIG_fail;
39107 temp3 = true;
39108 }
39109 if (obj3) {
39110 {
39111 arg4 = wxString_in_helper(obj3);
39112 if (arg4 == NULL) SWIG_fail;
39113 temp4 = true;
39114 }
39115 }
39116 {
39117 PyThreadState* __tstate = wxPyBeginAllowThreads();
39118 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39119 wxPyEndAllowThreads(__tstate);
39120 if (PyErr_Occurred()) SWIG_fail;
39121 }
39122 {
39123 resultobj = wxPyMake_wxObject(result, (bool)0);
39124 }
39125 {
39126 if (temp3)
39127 delete arg3;
39128 }
39129 {
39130 if (temp4)
39131 delete arg4;
39132 }
39133 return resultobj;
39134 fail:
39135 {
39136 if (temp3)
39137 delete arg3;
39138 }
39139 {
39140 if (temp4)
39141 delete arg4;
39142 }
39143 return NULL;
39144 }
39145
39146
39147 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39148 PyObject *resultobj = 0;
39149 wxMenu *arg1 = (wxMenu *) 0 ;
39150 int arg2 ;
39151 wxString *arg3 = 0 ;
39152 wxString const &arg4_defvalue = wxPyEmptyString ;
39153 wxString *arg4 = (wxString *) &arg4_defvalue ;
39154 wxMenuItem *result = 0 ;
39155 void *argp1 = 0 ;
39156 int res1 = 0 ;
39157 int val2 ;
39158 int ecode2 = 0 ;
39159 bool temp3 = false ;
39160 bool temp4 = false ;
39161 PyObject * obj0 = 0 ;
39162 PyObject * obj1 = 0 ;
39163 PyObject * obj2 = 0 ;
39164 PyObject * obj3 = 0 ;
39165 char * kwnames[] = {
39166 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39167 };
39168
39169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39171 if (!SWIG_IsOK(res1)) {
39172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39173 }
39174 arg1 = reinterpret_cast< wxMenu * >(argp1);
39175 ecode2 = SWIG_AsVal_int(obj1, &val2);
39176 if (!SWIG_IsOK(ecode2)) {
39177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39178 }
39179 arg2 = static_cast< int >(val2);
39180 {
39181 arg3 = wxString_in_helper(obj2);
39182 if (arg3 == NULL) SWIG_fail;
39183 temp3 = true;
39184 }
39185 if (obj3) {
39186 {
39187 arg4 = wxString_in_helper(obj3);
39188 if (arg4 == NULL) SWIG_fail;
39189 temp4 = true;
39190 }
39191 }
39192 {
39193 PyThreadState* __tstate = wxPyBeginAllowThreads();
39194 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39195 wxPyEndAllowThreads(__tstate);
39196 if (PyErr_Occurred()) SWIG_fail;
39197 }
39198 {
39199 resultobj = wxPyMake_wxObject(result, (bool)0);
39200 }
39201 {
39202 if (temp3)
39203 delete arg3;
39204 }
39205 {
39206 if (temp4)
39207 delete arg4;
39208 }
39209 return resultobj;
39210 fail:
39211 {
39212 if (temp3)
39213 delete arg3;
39214 }
39215 {
39216 if (temp4)
39217 delete arg4;
39218 }
39219 return NULL;
39220 }
39221
39222
39223 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39224 PyObject *resultobj = 0;
39225 wxMenu *arg1 = (wxMenu *) 0 ;
39226 int arg2 ;
39227 wxString *arg3 = 0 ;
39228 wxMenu *arg4 = (wxMenu *) 0 ;
39229 wxString const &arg5_defvalue = wxPyEmptyString ;
39230 wxString *arg5 = (wxString *) &arg5_defvalue ;
39231 wxMenuItem *result = 0 ;
39232 void *argp1 = 0 ;
39233 int res1 = 0 ;
39234 int val2 ;
39235 int ecode2 = 0 ;
39236 bool temp3 = false ;
39237 void *argp4 = 0 ;
39238 int res4 = 0 ;
39239 bool temp5 = false ;
39240 PyObject * obj0 = 0 ;
39241 PyObject * obj1 = 0 ;
39242 PyObject * obj2 = 0 ;
39243 PyObject * obj3 = 0 ;
39244 PyObject * obj4 = 0 ;
39245 char * kwnames[] = {
39246 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39247 };
39248
39249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39251 if (!SWIG_IsOK(res1)) {
39252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39253 }
39254 arg1 = reinterpret_cast< wxMenu * >(argp1);
39255 ecode2 = SWIG_AsVal_int(obj1, &val2);
39256 if (!SWIG_IsOK(ecode2)) {
39257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39258 }
39259 arg2 = static_cast< int >(val2);
39260 {
39261 arg3 = wxString_in_helper(obj2);
39262 if (arg3 == NULL) SWIG_fail;
39263 temp3 = true;
39264 }
39265 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39266 if (!SWIG_IsOK(res4)) {
39267 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39268 }
39269 arg4 = reinterpret_cast< wxMenu * >(argp4);
39270 if (obj4) {
39271 {
39272 arg5 = wxString_in_helper(obj4);
39273 if (arg5 == NULL) SWIG_fail;
39274 temp5 = true;
39275 }
39276 }
39277 {
39278 PyThreadState* __tstate = wxPyBeginAllowThreads();
39279 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39280 wxPyEndAllowThreads(__tstate);
39281 if (PyErr_Occurred()) SWIG_fail;
39282 }
39283 {
39284 resultobj = wxPyMake_wxObject(result, (bool)0);
39285 }
39286 {
39287 if (temp3)
39288 delete arg3;
39289 }
39290 {
39291 if (temp5)
39292 delete arg5;
39293 }
39294 return resultobj;
39295 fail:
39296 {
39297 if (temp3)
39298 delete arg3;
39299 }
39300 {
39301 if (temp5)
39302 delete arg5;
39303 }
39304 return NULL;
39305 }
39306
39307
39308 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39309 PyObject *resultobj = 0;
39310 wxMenu *arg1 = (wxMenu *) 0 ;
39311 wxMenu *arg2 = (wxMenu *) 0 ;
39312 wxString *arg3 = 0 ;
39313 wxString const &arg4_defvalue = wxPyEmptyString ;
39314 wxString *arg4 = (wxString *) &arg4_defvalue ;
39315 wxMenuItem *result = 0 ;
39316 void *argp1 = 0 ;
39317 int res1 = 0 ;
39318 void *argp2 = 0 ;
39319 int res2 = 0 ;
39320 bool temp3 = false ;
39321 bool temp4 = false ;
39322 PyObject * obj0 = 0 ;
39323 PyObject * obj1 = 0 ;
39324 PyObject * obj2 = 0 ;
39325 PyObject * obj3 = 0 ;
39326 char * kwnames[] = {
39327 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39328 };
39329
39330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39332 if (!SWIG_IsOK(res1)) {
39333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39334 }
39335 arg1 = reinterpret_cast< wxMenu * >(argp1);
39336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39337 if (!SWIG_IsOK(res2)) {
39338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39339 }
39340 arg2 = reinterpret_cast< wxMenu * >(argp2);
39341 {
39342 arg3 = wxString_in_helper(obj2);
39343 if (arg3 == NULL) SWIG_fail;
39344 temp3 = true;
39345 }
39346 if (obj3) {
39347 {
39348 arg4 = wxString_in_helper(obj3);
39349 if (arg4 == NULL) SWIG_fail;
39350 temp4 = true;
39351 }
39352 }
39353 {
39354 PyThreadState* __tstate = wxPyBeginAllowThreads();
39355 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39356 wxPyEndAllowThreads(__tstate);
39357 if (PyErr_Occurred()) SWIG_fail;
39358 }
39359 {
39360 resultobj = wxPyMake_wxObject(result, (bool)0);
39361 }
39362 {
39363 if (temp3)
39364 delete arg3;
39365 }
39366 {
39367 if (temp4)
39368 delete arg4;
39369 }
39370 return resultobj;
39371 fail:
39372 {
39373 if (temp3)
39374 delete arg3;
39375 }
39376 {
39377 if (temp4)
39378 delete arg4;
39379 }
39380 return NULL;
39381 }
39382
39383
39384 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39385 PyObject *resultobj = 0;
39386 wxMenu *arg1 = (wxMenu *) 0 ;
39387 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39388 wxMenuItem *result = 0 ;
39389 void *argp1 = 0 ;
39390 int res1 = 0 ;
39391 int res2 = 0 ;
39392 PyObject * obj0 = 0 ;
39393 PyObject * obj1 = 0 ;
39394 char * kwnames[] = {
39395 (char *) "self",(char *) "item", NULL
39396 };
39397
39398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39400 if (!SWIG_IsOK(res1)) {
39401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39402 }
39403 arg1 = reinterpret_cast< wxMenu * >(argp1);
39404 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39405 if (!SWIG_IsOK(res2)) {
39406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39407 }
39408 {
39409 PyThreadState* __tstate = wxPyBeginAllowThreads();
39410 result = (wxMenuItem *)(arg1)->Append(arg2);
39411 wxPyEndAllowThreads(__tstate);
39412 if (PyErr_Occurred()) SWIG_fail;
39413 }
39414 {
39415 resultobj = wxPyMake_wxObject(result, (bool)0);
39416 }
39417 return resultobj;
39418 fail:
39419 return NULL;
39420 }
39421
39422
39423 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39424 PyObject *resultobj = 0;
39425 wxMenu *arg1 = (wxMenu *) 0 ;
39426 size_t arg2 ;
39427 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39428 wxMenuItem *result = 0 ;
39429 void *argp1 = 0 ;
39430 int res1 = 0 ;
39431 size_t val2 ;
39432 int ecode2 = 0 ;
39433 int res3 = 0 ;
39434 PyObject * obj0 = 0 ;
39435 PyObject * obj1 = 0 ;
39436 PyObject * obj2 = 0 ;
39437 char * kwnames[] = {
39438 (char *) "self",(char *) "pos",(char *) "item", NULL
39439 };
39440
39441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39443 if (!SWIG_IsOK(res1)) {
39444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39445 }
39446 arg1 = reinterpret_cast< wxMenu * >(argp1);
39447 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39448 if (!SWIG_IsOK(ecode2)) {
39449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39450 }
39451 arg2 = static_cast< size_t >(val2);
39452 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39453 if (!SWIG_IsOK(res3)) {
39454 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39455 }
39456 {
39457 PyThreadState* __tstate = wxPyBeginAllowThreads();
39458 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39459 wxPyEndAllowThreads(__tstate);
39460 if (PyErr_Occurred()) SWIG_fail;
39461 }
39462 {
39463 resultobj = wxPyMake_wxObject(result, (bool)0);
39464 }
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39472 PyObject *resultobj = 0;
39473 wxMenu *arg1 = (wxMenu *) 0 ;
39474 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39475 wxMenuItem *result = 0 ;
39476 void *argp1 = 0 ;
39477 int res1 = 0 ;
39478 int res2 = 0 ;
39479 PyObject * obj0 = 0 ;
39480 PyObject * obj1 = 0 ;
39481 char * kwnames[] = {
39482 (char *) "self",(char *) "item", NULL
39483 };
39484
39485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39487 if (!SWIG_IsOK(res1)) {
39488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39489 }
39490 arg1 = reinterpret_cast< wxMenu * >(argp1);
39491 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39492 if (!SWIG_IsOK(res2)) {
39493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39494 }
39495 {
39496 PyThreadState* __tstate = wxPyBeginAllowThreads();
39497 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39498 wxPyEndAllowThreads(__tstate);
39499 if (PyErr_Occurred()) SWIG_fail;
39500 }
39501 {
39502 resultobj = wxPyMake_wxObject(result, (bool)0);
39503 }
39504 return resultobj;
39505 fail:
39506 return NULL;
39507 }
39508
39509
39510 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39511 PyObject *resultobj = 0;
39512 wxMenu *arg1 = (wxMenu *) 0 ;
39513 void *argp1 = 0 ;
39514 int res1 = 0 ;
39515 PyObject *swig_obj[1] ;
39516
39517 if (!args) SWIG_fail;
39518 swig_obj[0] = args;
39519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39520 if (!SWIG_IsOK(res1)) {
39521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39522 }
39523 arg1 = reinterpret_cast< wxMenu * >(argp1);
39524 {
39525 PyThreadState* __tstate = wxPyBeginAllowThreads();
39526 (arg1)->Break();
39527 wxPyEndAllowThreads(__tstate);
39528 if (PyErr_Occurred()) SWIG_fail;
39529 }
39530 resultobj = SWIG_Py_Void();
39531 return resultobj;
39532 fail:
39533 return NULL;
39534 }
39535
39536
39537 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39538 PyObject *resultobj = 0;
39539 wxMenu *arg1 = (wxMenu *) 0 ;
39540 size_t arg2 ;
39541 int arg3 ;
39542 wxString const &arg4_defvalue = wxPyEmptyString ;
39543 wxString *arg4 = (wxString *) &arg4_defvalue ;
39544 wxString const &arg5_defvalue = wxPyEmptyString ;
39545 wxString *arg5 = (wxString *) &arg5_defvalue ;
39546 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39547 wxMenuItem *result = 0 ;
39548 void *argp1 = 0 ;
39549 int res1 = 0 ;
39550 size_t val2 ;
39551 int ecode2 = 0 ;
39552 int val3 ;
39553 int ecode3 = 0 ;
39554 bool temp4 = false ;
39555 bool temp5 = false ;
39556 int val6 ;
39557 int ecode6 = 0 ;
39558 PyObject * obj0 = 0 ;
39559 PyObject * obj1 = 0 ;
39560 PyObject * obj2 = 0 ;
39561 PyObject * obj3 = 0 ;
39562 PyObject * obj4 = 0 ;
39563 PyObject * obj5 = 0 ;
39564 char * kwnames[] = {
39565 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39566 };
39567
39568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39570 if (!SWIG_IsOK(res1)) {
39571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39572 }
39573 arg1 = reinterpret_cast< wxMenu * >(argp1);
39574 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39575 if (!SWIG_IsOK(ecode2)) {
39576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39577 }
39578 arg2 = static_cast< size_t >(val2);
39579 ecode3 = SWIG_AsVal_int(obj2, &val3);
39580 if (!SWIG_IsOK(ecode3)) {
39581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39582 }
39583 arg3 = static_cast< int >(val3);
39584 if (obj3) {
39585 {
39586 arg4 = wxString_in_helper(obj3);
39587 if (arg4 == NULL) SWIG_fail;
39588 temp4 = true;
39589 }
39590 }
39591 if (obj4) {
39592 {
39593 arg5 = wxString_in_helper(obj4);
39594 if (arg5 == NULL) SWIG_fail;
39595 temp5 = true;
39596 }
39597 }
39598 if (obj5) {
39599 ecode6 = SWIG_AsVal_int(obj5, &val6);
39600 if (!SWIG_IsOK(ecode6)) {
39601 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39602 }
39603 arg6 = static_cast< wxItemKind >(val6);
39604 }
39605 {
39606 PyThreadState* __tstate = wxPyBeginAllowThreads();
39607 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39608 wxPyEndAllowThreads(__tstate);
39609 if (PyErr_Occurred()) SWIG_fail;
39610 }
39611 {
39612 resultobj = wxPyMake_wxObject(result, (bool)0);
39613 }
39614 {
39615 if (temp4)
39616 delete arg4;
39617 }
39618 {
39619 if (temp5)
39620 delete arg5;
39621 }
39622 return resultobj;
39623 fail:
39624 {
39625 if (temp4)
39626 delete arg4;
39627 }
39628 {
39629 if (temp5)
39630 delete arg5;
39631 }
39632 return NULL;
39633 }
39634
39635
39636 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39637 PyObject *resultobj = 0;
39638 wxMenu *arg1 = (wxMenu *) 0 ;
39639 size_t arg2 ;
39640 wxMenuItem *result = 0 ;
39641 void *argp1 = 0 ;
39642 int res1 = 0 ;
39643 size_t val2 ;
39644 int ecode2 = 0 ;
39645 PyObject * obj0 = 0 ;
39646 PyObject * obj1 = 0 ;
39647 char * kwnames[] = {
39648 (char *) "self",(char *) "pos", NULL
39649 };
39650
39651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39653 if (!SWIG_IsOK(res1)) {
39654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39655 }
39656 arg1 = reinterpret_cast< wxMenu * >(argp1);
39657 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39658 if (!SWIG_IsOK(ecode2)) {
39659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39660 }
39661 arg2 = static_cast< size_t >(val2);
39662 {
39663 PyThreadState* __tstate = wxPyBeginAllowThreads();
39664 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39665 wxPyEndAllowThreads(__tstate);
39666 if (PyErr_Occurred()) SWIG_fail;
39667 }
39668 {
39669 resultobj = wxPyMake_wxObject(result, (bool)0);
39670 }
39671 return resultobj;
39672 fail:
39673 return NULL;
39674 }
39675
39676
39677 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39678 PyObject *resultobj = 0;
39679 wxMenu *arg1 = (wxMenu *) 0 ;
39680 size_t arg2 ;
39681 int arg3 ;
39682 wxString *arg4 = 0 ;
39683 wxString const &arg5_defvalue = wxPyEmptyString ;
39684 wxString *arg5 = (wxString *) &arg5_defvalue ;
39685 wxMenuItem *result = 0 ;
39686 void *argp1 = 0 ;
39687 int res1 = 0 ;
39688 size_t val2 ;
39689 int ecode2 = 0 ;
39690 int val3 ;
39691 int ecode3 = 0 ;
39692 bool temp4 = false ;
39693 bool temp5 = false ;
39694 PyObject * obj0 = 0 ;
39695 PyObject * obj1 = 0 ;
39696 PyObject * obj2 = 0 ;
39697 PyObject * obj3 = 0 ;
39698 PyObject * obj4 = 0 ;
39699 char * kwnames[] = {
39700 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39701 };
39702
39703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39705 if (!SWIG_IsOK(res1)) {
39706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39707 }
39708 arg1 = reinterpret_cast< wxMenu * >(argp1);
39709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39710 if (!SWIG_IsOK(ecode2)) {
39711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39712 }
39713 arg2 = static_cast< size_t >(val2);
39714 ecode3 = SWIG_AsVal_int(obj2, &val3);
39715 if (!SWIG_IsOK(ecode3)) {
39716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39717 }
39718 arg3 = static_cast< int >(val3);
39719 {
39720 arg4 = wxString_in_helper(obj3);
39721 if (arg4 == NULL) SWIG_fail;
39722 temp4 = true;
39723 }
39724 if (obj4) {
39725 {
39726 arg5 = wxString_in_helper(obj4);
39727 if (arg5 == NULL) SWIG_fail;
39728 temp5 = true;
39729 }
39730 }
39731 {
39732 PyThreadState* __tstate = wxPyBeginAllowThreads();
39733 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39734 wxPyEndAllowThreads(__tstate);
39735 if (PyErr_Occurred()) SWIG_fail;
39736 }
39737 {
39738 resultobj = wxPyMake_wxObject(result, (bool)0);
39739 }
39740 {
39741 if (temp4)
39742 delete arg4;
39743 }
39744 {
39745 if (temp5)
39746 delete arg5;
39747 }
39748 return resultobj;
39749 fail:
39750 {
39751 if (temp4)
39752 delete arg4;
39753 }
39754 {
39755 if (temp5)
39756 delete arg5;
39757 }
39758 return NULL;
39759 }
39760
39761
39762 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39763 PyObject *resultobj = 0;
39764 wxMenu *arg1 = (wxMenu *) 0 ;
39765 size_t arg2 ;
39766 int arg3 ;
39767 wxString *arg4 = 0 ;
39768 wxString const &arg5_defvalue = wxPyEmptyString ;
39769 wxString *arg5 = (wxString *) &arg5_defvalue ;
39770 wxMenuItem *result = 0 ;
39771 void *argp1 = 0 ;
39772 int res1 = 0 ;
39773 size_t val2 ;
39774 int ecode2 = 0 ;
39775 int val3 ;
39776 int ecode3 = 0 ;
39777 bool temp4 = false ;
39778 bool temp5 = false ;
39779 PyObject * obj0 = 0 ;
39780 PyObject * obj1 = 0 ;
39781 PyObject * obj2 = 0 ;
39782 PyObject * obj3 = 0 ;
39783 PyObject * obj4 = 0 ;
39784 char * kwnames[] = {
39785 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39786 };
39787
39788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39790 if (!SWIG_IsOK(res1)) {
39791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39792 }
39793 arg1 = reinterpret_cast< wxMenu * >(argp1);
39794 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39795 if (!SWIG_IsOK(ecode2)) {
39796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39797 }
39798 arg2 = static_cast< size_t >(val2);
39799 ecode3 = SWIG_AsVal_int(obj2, &val3);
39800 if (!SWIG_IsOK(ecode3)) {
39801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39802 }
39803 arg3 = static_cast< int >(val3);
39804 {
39805 arg4 = wxString_in_helper(obj3);
39806 if (arg4 == NULL) SWIG_fail;
39807 temp4 = true;
39808 }
39809 if (obj4) {
39810 {
39811 arg5 = wxString_in_helper(obj4);
39812 if (arg5 == NULL) SWIG_fail;
39813 temp5 = true;
39814 }
39815 }
39816 {
39817 PyThreadState* __tstate = wxPyBeginAllowThreads();
39818 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39819 wxPyEndAllowThreads(__tstate);
39820 if (PyErr_Occurred()) SWIG_fail;
39821 }
39822 {
39823 resultobj = wxPyMake_wxObject(result, (bool)0);
39824 }
39825 {
39826 if (temp4)
39827 delete arg4;
39828 }
39829 {
39830 if (temp5)
39831 delete arg5;
39832 }
39833 return resultobj;
39834 fail:
39835 {
39836 if (temp4)
39837 delete arg4;
39838 }
39839 {
39840 if (temp5)
39841 delete arg5;
39842 }
39843 return NULL;
39844 }
39845
39846
39847 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39848 PyObject *resultobj = 0;
39849 wxMenu *arg1 = (wxMenu *) 0 ;
39850 size_t arg2 ;
39851 int arg3 ;
39852 wxString *arg4 = 0 ;
39853 wxMenu *arg5 = (wxMenu *) 0 ;
39854 wxString const &arg6_defvalue = wxPyEmptyString ;
39855 wxString *arg6 = (wxString *) &arg6_defvalue ;
39856 wxMenuItem *result = 0 ;
39857 void *argp1 = 0 ;
39858 int res1 = 0 ;
39859 size_t val2 ;
39860 int ecode2 = 0 ;
39861 int val3 ;
39862 int ecode3 = 0 ;
39863 bool temp4 = false ;
39864 void *argp5 = 0 ;
39865 int res5 = 0 ;
39866 bool temp6 = false ;
39867 PyObject * obj0 = 0 ;
39868 PyObject * obj1 = 0 ;
39869 PyObject * obj2 = 0 ;
39870 PyObject * obj3 = 0 ;
39871 PyObject * obj4 = 0 ;
39872 PyObject * obj5 = 0 ;
39873 char * kwnames[] = {
39874 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39875 };
39876
39877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39879 if (!SWIG_IsOK(res1)) {
39880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39881 }
39882 arg1 = reinterpret_cast< wxMenu * >(argp1);
39883 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39884 if (!SWIG_IsOK(ecode2)) {
39885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39886 }
39887 arg2 = static_cast< size_t >(val2);
39888 ecode3 = SWIG_AsVal_int(obj2, &val3);
39889 if (!SWIG_IsOK(ecode3)) {
39890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39891 }
39892 arg3 = static_cast< int >(val3);
39893 {
39894 arg4 = wxString_in_helper(obj3);
39895 if (arg4 == NULL) SWIG_fail;
39896 temp4 = true;
39897 }
39898 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39899 if (!SWIG_IsOK(res5)) {
39900 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39901 }
39902 arg5 = reinterpret_cast< wxMenu * >(argp5);
39903 if (obj5) {
39904 {
39905 arg6 = wxString_in_helper(obj5);
39906 if (arg6 == NULL) SWIG_fail;
39907 temp6 = true;
39908 }
39909 }
39910 {
39911 PyThreadState* __tstate = wxPyBeginAllowThreads();
39912 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 {
39917 resultobj = wxPyMake_wxObject(result, (bool)0);
39918 }
39919 {
39920 if (temp4)
39921 delete arg4;
39922 }
39923 {
39924 if (temp6)
39925 delete arg6;
39926 }
39927 return resultobj;
39928 fail:
39929 {
39930 if (temp4)
39931 delete arg4;
39932 }
39933 {
39934 if (temp6)
39935 delete arg6;
39936 }
39937 return NULL;
39938 }
39939
39940
39941 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39942 PyObject *resultobj = 0;
39943 wxMenu *arg1 = (wxMenu *) 0 ;
39944 int arg2 ;
39945 wxString const &arg3_defvalue = wxPyEmptyString ;
39946 wxString *arg3 = (wxString *) &arg3_defvalue ;
39947 wxString const &arg4_defvalue = wxPyEmptyString ;
39948 wxString *arg4 = (wxString *) &arg4_defvalue ;
39949 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39950 wxMenuItem *result = 0 ;
39951 void *argp1 = 0 ;
39952 int res1 = 0 ;
39953 int val2 ;
39954 int ecode2 = 0 ;
39955 bool temp3 = false ;
39956 bool temp4 = false ;
39957 int val5 ;
39958 int ecode5 = 0 ;
39959 PyObject * obj0 = 0 ;
39960 PyObject * obj1 = 0 ;
39961 PyObject * obj2 = 0 ;
39962 PyObject * obj3 = 0 ;
39963 PyObject * obj4 = 0 ;
39964 char * kwnames[] = {
39965 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39966 };
39967
39968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39972 }
39973 arg1 = reinterpret_cast< wxMenu * >(argp1);
39974 ecode2 = SWIG_AsVal_int(obj1, &val2);
39975 if (!SWIG_IsOK(ecode2)) {
39976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39977 }
39978 arg2 = static_cast< int >(val2);
39979 if (obj2) {
39980 {
39981 arg3 = wxString_in_helper(obj2);
39982 if (arg3 == NULL) SWIG_fail;
39983 temp3 = true;
39984 }
39985 }
39986 if (obj3) {
39987 {
39988 arg4 = wxString_in_helper(obj3);
39989 if (arg4 == NULL) SWIG_fail;
39990 temp4 = true;
39991 }
39992 }
39993 if (obj4) {
39994 ecode5 = SWIG_AsVal_int(obj4, &val5);
39995 if (!SWIG_IsOK(ecode5)) {
39996 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39997 }
39998 arg5 = static_cast< wxItemKind >(val5);
39999 }
40000 {
40001 PyThreadState* __tstate = wxPyBeginAllowThreads();
40002 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40003 wxPyEndAllowThreads(__tstate);
40004 if (PyErr_Occurred()) SWIG_fail;
40005 }
40006 {
40007 resultobj = wxPyMake_wxObject(result, (bool)0);
40008 }
40009 {
40010 if (temp3)
40011 delete arg3;
40012 }
40013 {
40014 if (temp4)
40015 delete arg4;
40016 }
40017 return resultobj;
40018 fail:
40019 {
40020 if (temp3)
40021 delete arg3;
40022 }
40023 {
40024 if (temp4)
40025 delete arg4;
40026 }
40027 return NULL;
40028 }
40029
40030
40031 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40032 PyObject *resultobj = 0;
40033 wxMenu *arg1 = (wxMenu *) 0 ;
40034 wxMenuItem *result = 0 ;
40035 void *argp1 = 0 ;
40036 int res1 = 0 ;
40037 PyObject *swig_obj[1] ;
40038
40039 if (!args) SWIG_fail;
40040 swig_obj[0] = args;
40041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40042 if (!SWIG_IsOK(res1)) {
40043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40044 }
40045 arg1 = reinterpret_cast< wxMenu * >(argp1);
40046 {
40047 PyThreadState* __tstate = wxPyBeginAllowThreads();
40048 result = (wxMenuItem *)(arg1)->PrependSeparator();
40049 wxPyEndAllowThreads(__tstate);
40050 if (PyErr_Occurred()) SWIG_fail;
40051 }
40052 {
40053 resultobj = wxPyMake_wxObject(result, (bool)0);
40054 }
40055 return resultobj;
40056 fail:
40057 return NULL;
40058 }
40059
40060
40061 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40062 PyObject *resultobj = 0;
40063 wxMenu *arg1 = (wxMenu *) 0 ;
40064 int arg2 ;
40065 wxString *arg3 = 0 ;
40066 wxString const &arg4_defvalue = wxPyEmptyString ;
40067 wxString *arg4 = (wxString *) &arg4_defvalue ;
40068 wxMenuItem *result = 0 ;
40069 void *argp1 = 0 ;
40070 int res1 = 0 ;
40071 int val2 ;
40072 int ecode2 = 0 ;
40073 bool temp3 = false ;
40074 bool temp4 = false ;
40075 PyObject * obj0 = 0 ;
40076 PyObject * obj1 = 0 ;
40077 PyObject * obj2 = 0 ;
40078 PyObject * obj3 = 0 ;
40079 char * kwnames[] = {
40080 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40081 };
40082
40083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40085 if (!SWIG_IsOK(res1)) {
40086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40087 }
40088 arg1 = reinterpret_cast< wxMenu * >(argp1);
40089 ecode2 = SWIG_AsVal_int(obj1, &val2);
40090 if (!SWIG_IsOK(ecode2)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40092 }
40093 arg2 = static_cast< int >(val2);
40094 {
40095 arg3 = wxString_in_helper(obj2);
40096 if (arg3 == NULL) SWIG_fail;
40097 temp3 = true;
40098 }
40099 if (obj3) {
40100 {
40101 arg4 = wxString_in_helper(obj3);
40102 if (arg4 == NULL) SWIG_fail;
40103 temp4 = true;
40104 }
40105 }
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 {
40113 resultobj = wxPyMake_wxObject(result, (bool)0);
40114 }
40115 {
40116 if (temp3)
40117 delete arg3;
40118 }
40119 {
40120 if (temp4)
40121 delete arg4;
40122 }
40123 return resultobj;
40124 fail:
40125 {
40126 if (temp3)
40127 delete arg3;
40128 }
40129 {
40130 if (temp4)
40131 delete arg4;
40132 }
40133 return NULL;
40134 }
40135
40136
40137 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40138 PyObject *resultobj = 0;
40139 wxMenu *arg1 = (wxMenu *) 0 ;
40140 int arg2 ;
40141 wxString *arg3 = 0 ;
40142 wxString const &arg4_defvalue = wxPyEmptyString ;
40143 wxString *arg4 = (wxString *) &arg4_defvalue ;
40144 wxMenuItem *result = 0 ;
40145 void *argp1 = 0 ;
40146 int res1 = 0 ;
40147 int val2 ;
40148 int ecode2 = 0 ;
40149 bool temp3 = false ;
40150 bool temp4 = false ;
40151 PyObject * obj0 = 0 ;
40152 PyObject * obj1 = 0 ;
40153 PyObject * obj2 = 0 ;
40154 PyObject * obj3 = 0 ;
40155 char * kwnames[] = {
40156 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40157 };
40158
40159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40161 if (!SWIG_IsOK(res1)) {
40162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40163 }
40164 arg1 = reinterpret_cast< wxMenu * >(argp1);
40165 ecode2 = SWIG_AsVal_int(obj1, &val2);
40166 if (!SWIG_IsOK(ecode2)) {
40167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40168 }
40169 arg2 = static_cast< int >(val2);
40170 {
40171 arg3 = wxString_in_helper(obj2);
40172 if (arg3 == NULL) SWIG_fail;
40173 temp3 = true;
40174 }
40175 if (obj3) {
40176 {
40177 arg4 = wxString_in_helper(obj3);
40178 if (arg4 == NULL) SWIG_fail;
40179 temp4 = true;
40180 }
40181 }
40182 {
40183 PyThreadState* __tstate = wxPyBeginAllowThreads();
40184 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40185 wxPyEndAllowThreads(__tstate);
40186 if (PyErr_Occurred()) SWIG_fail;
40187 }
40188 {
40189 resultobj = wxPyMake_wxObject(result, (bool)0);
40190 }
40191 {
40192 if (temp3)
40193 delete arg3;
40194 }
40195 {
40196 if (temp4)
40197 delete arg4;
40198 }
40199 return resultobj;
40200 fail:
40201 {
40202 if (temp3)
40203 delete arg3;
40204 }
40205 {
40206 if (temp4)
40207 delete arg4;
40208 }
40209 return NULL;
40210 }
40211
40212
40213 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40214 PyObject *resultobj = 0;
40215 wxMenu *arg1 = (wxMenu *) 0 ;
40216 int arg2 ;
40217 wxString *arg3 = 0 ;
40218 wxMenu *arg4 = (wxMenu *) 0 ;
40219 wxString const &arg5_defvalue = wxPyEmptyString ;
40220 wxString *arg5 = (wxString *) &arg5_defvalue ;
40221 wxMenuItem *result = 0 ;
40222 void *argp1 = 0 ;
40223 int res1 = 0 ;
40224 int val2 ;
40225 int ecode2 = 0 ;
40226 bool temp3 = false ;
40227 void *argp4 = 0 ;
40228 int res4 = 0 ;
40229 bool temp5 = false ;
40230 PyObject * obj0 = 0 ;
40231 PyObject * obj1 = 0 ;
40232 PyObject * obj2 = 0 ;
40233 PyObject * obj3 = 0 ;
40234 PyObject * obj4 = 0 ;
40235 char * kwnames[] = {
40236 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40237 };
40238
40239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40241 if (!SWIG_IsOK(res1)) {
40242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40243 }
40244 arg1 = reinterpret_cast< wxMenu * >(argp1);
40245 ecode2 = SWIG_AsVal_int(obj1, &val2);
40246 if (!SWIG_IsOK(ecode2)) {
40247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40248 }
40249 arg2 = static_cast< int >(val2);
40250 {
40251 arg3 = wxString_in_helper(obj2);
40252 if (arg3 == NULL) SWIG_fail;
40253 temp3 = true;
40254 }
40255 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40256 if (!SWIG_IsOK(res4)) {
40257 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40258 }
40259 arg4 = reinterpret_cast< wxMenu * >(argp4);
40260 if (obj4) {
40261 {
40262 arg5 = wxString_in_helper(obj4);
40263 if (arg5 == NULL) SWIG_fail;
40264 temp5 = true;
40265 }
40266 }
40267 {
40268 PyThreadState* __tstate = wxPyBeginAllowThreads();
40269 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40270 wxPyEndAllowThreads(__tstate);
40271 if (PyErr_Occurred()) SWIG_fail;
40272 }
40273 {
40274 resultobj = wxPyMake_wxObject(result, (bool)0);
40275 }
40276 {
40277 if (temp3)
40278 delete arg3;
40279 }
40280 {
40281 if (temp5)
40282 delete arg5;
40283 }
40284 return resultobj;
40285 fail:
40286 {
40287 if (temp3)
40288 delete arg3;
40289 }
40290 {
40291 if (temp5)
40292 delete arg5;
40293 }
40294 return NULL;
40295 }
40296
40297
40298 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40299 PyObject *resultobj = 0;
40300 wxMenu *arg1 = (wxMenu *) 0 ;
40301 int arg2 ;
40302 wxMenuItem *result = 0 ;
40303 void *argp1 = 0 ;
40304 int res1 = 0 ;
40305 int val2 ;
40306 int ecode2 = 0 ;
40307 PyObject * obj0 = 0 ;
40308 PyObject * obj1 = 0 ;
40309 char * kwnames[] = {
40310 (char *) "self",(char *) "id", NULL
40311 };
40312
40313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40315 if (!SWIG_IsOK(res1)) {
40316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40317 }
40318 arg1 = reinterpret_cast< wxMenu * >(argp1);
40319 ecode2 = SWIG_AsVal_int(obj1, &val2);
40320 if (!SWIG_IsOK(ecode2)) {
40321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40322 }
40323 arg2 = static_cast< int >(val2);
40324 {
40325 PyThreadState* __tstate = wxPyBeginAllowThreads();
40326 result = (wxMenuItem *)(arg1)->Remove(arg2);
40327 wxPyEndAllowThreads(__tstate);
40328 if (PyErr_Occurred()) SWIG_fail;
40329 }
40330 {
40331 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40332 }
40333 return resultobj;
40334 fail:
40335 return NULL;
40336 }
40337
40338
40339 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40340 PyObject *resultobj = 0;
40341 wxMenu *arg1 = (wxMenu *) 0 ;
40342 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40343 wxMenuItem *result = 0 ;
40344 void *argp1 = 0 ;
40345 int res1 = 0 ;
40346 void *argp2 = 0 ;
40347 int res2 = 0 ;
40348 PyObject * obj0 = 0 ;
40349 PyObject * obj1 = 0 ;
40350 char * kwnames[] = {
40351 (char *) "self",(char *) "item", NULL
40352 };
40353
40354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40356 if (!SWIG_IsOK(res1)) {
40357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40358 }
40359 arg1 = reinterpret_cast< wxMenu * >(argp1);
40360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40361 if (!SWIG_IsOK(res2)) {
40362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40363 }
40364 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40365 {
40366 PyThreadState* __tstate = wxPyBeginAllowThreads();
40367 result = (wxMenuItem *)(arg1)->Remove(arg2);
40368 wxPyEndAllowThreads(__tstate);
40369 if (PyErr_Occurred()) SWIG_fail;
40370 }
40371 {
40372 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40373 }
40374 return resultobj;
40375 fail:
40376 return NULL;
40377 }
40378
40379
40380 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40381 PyObject *resultobj = 0;
40382 wxMenu *arg1 = (wxMenu *) 0 ;
40383 int arg2 ;
40384 bool result;
40385 void *argp1 = 0 ;
40386 int res1 = 0 ;
40387 int val2 ;
40388 int ecode2 = 0 ;
40389 PyObject * obj0 = 0 ;
40390 PyObject * obj1 = 0 ;
40391 char * kwnames[] = {
40392 (char *) "self",(char *) "id", NULL
40393 };
40394
40395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40397 if (!SWIG_IsOK(res1)) {
40398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40399 }
40400 arg1 = reinterpret_cast< wxMenu * >(argp1);
40401 ecode2 = SWIG_AsVal_int(obj1, &val2);
40402 if (!SWIG_IsOK(ecode2)) {
40403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40404 }
40405 arg2 = static_cast< int >(val2);
40406 {
40407 PyThreadState* __tstate = wxPyBeginAllowThreads();
40408 result = (bool)(arg1)->Delete(arg2);
40409 wxPyEndAllowThreads(__tstate);
40410 if (PyErr_Occurred()) SWIG_fail;
40411 }
40412 {
40413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40414 }
40415 return resultobj;
40416 fail:
40417 return NULL;
40418 }
40419
40420
40421 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40422 PyObject *resultobj = 0;
40423 wxMenu *arg1 = (wxMenu *) 0 ;
40424 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40425 bool result;
40426 void *argp1 = 0 ;
40427 int res1 = 0 ;
40428 void *argp2 = 0 ;
40429 int res2 = 0 ;
40430 PyObject * obj0 = 0 ;
40431 PyObject * obj1 = 0 ;
40432 char * kwnames[] = {
40433 (char *) "self",(char *) "item", NULL
40434 };
40435
40436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40438 if (!SWIG_IsOK(res1)) {
40439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40440 }
40441 arg1 = reinterpret_cast< wxMenu * >(argp1);
40442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40443 if (!SWIG_IsOK(res2)) {
40444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40445 }
40446 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40447 {
40448 PyThreadState* __tstate = wxPyBeginAllowThreads();
40449 result = (bool)(arg1)->Delete(arg2);
40450 wxPyEndAllowThreads(__tstate);
40451 if (PyErr_Occurred()) SWIG_fail;
40452 }
40453 {
40454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40455 }
40456 return resultobj;
40457 fail:
40458 return NULL;
40459 }
40460
40461
40462 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40463 PyObject *resultobj = 0;
40464 wxMenu *arg1 = (wxMenu *) 0 ;
40465 void *argp1 = 0 ;
40466 int res1 = 0 ;
40467 PyObject *swig_obj[1] ;
40468
40469 if (!args) SWIG_fail;
40470 swig_obj[0] = args;
40471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40472 if (!SWIG_IsOK(res1)) {
40473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40474 }
40475 arg1 = reinterpret_cast< wxMenu * >(argp1);
40476 {
40477 PyThreadState* __tstate = wxPyBeginAllowThreads();
40478 wxMenu_Destroy(arg1);
40479 wxPyEndAllowThreads(__tstate);
40480 if (PyErr_Occurred()) SWIG_fail;
40481 }
40482 resultobj = SWIG_Py_Void();
40483 return resultobj;
40484 fail:
40485 return NULL;
40486 }
40487
40488
40489 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40490 PyObject *resultobj = 0;
40491 wxMenu *arg1 = (wxMenu *) 0 ;
40492 int arg2 ;
40493 bool result;
40494 void *argp1 = 0 ;
40495 int res1 = 0 ;
40496 int val2 ;
40497 int ecode2 = 0 ;
40498 PyObject * obj0 = 0 ;
40499 PyObject * obj1 = 0 ;
40500 char * kwnames[] = {
40501 (char *) "self",(char *) "id", NULL
40502 };
40503
40504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40506 if (!SWIG_IsOK(res1)) {
40507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40508 }
40509 arg1 = reinterpret_cast< wxMenu * >(argp1);
40510 ecode2 = SWIG_AsVal_int(obj1, &val2);
40511 if (!SWIG_IsOK(ecode2)) {
40512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40513 }
40514 arg2 = static_cast< int >(val2);
40515 {
40516 PyThreadState* __tstate = wxPyBeginAllowThreads();
40517 result = (bool)(arg1)->Destroy(arg2);
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 {
40522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40523 }
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40531 PyObject *resultobj = 0;
40532 wxMenu *arg1 = (wxMenu *) 0 ;
40533 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40534 bool result;
40535 void *argp1 = 0 ;
40536 int res1 = 0 ;
40537 void *argp2 = 0 ;
40538 int res2 = 0 ;
40539 PyObject * obj0 = 0 ;
40540 PyObject * obj1 = 0 ;
40541 char * kwnames[] = {
40542 (char *) "self",(char *) "item", NULL
40543 };
40544
40545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40547 if (!SWIG_IsOK(res1)) {
40548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40549 }
40550 arg1 = reinterpret_cast< wxMenu * >(argp1);
40551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40552 if (!SWIG_IsOK(res2)) {
40553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40554 }
40555 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40556 {
40557 PyThreadState* __tstate = wxPyBeginAllowThreads();
40558 result = (bool)(arg1)->Destroy(arg2);
40559 wxPyEndAllowThreads(__tstate);
40560 if (PyErr_Occurred()) SWIG_fail;
40561 }
40562 {
40563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40564 }
40565 return resultobj;
40566 fail:
40567 return NULL;
40568 }
40569
40570
40571 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40572 PyObject *resultobj = 0;
40573 wxMenu *arg1 = (wxMenu *) 0 ;
40574 size_t result;
40575 void *argp1 = 0 ;
40576 int res1 = 0 ;
40577 PyObject *swig_obj[1] ;
40578
40579 if (!args) SWIG_fail;
40580 swig_obj[0] = args;
40581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40582 if (!SWIG_IsOK(res1)) {
40583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40584 }
40585 arg1 = reinterpret_cast< wxMenu * >(argp1);
40586 {
40587 PyThreadState* __tstate = wxPyBeginAllowThreads();
40588 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40589 wxPyEndAllowThreads(__tstate);
40590 if (PyErr_Occurred()) SWIG_fail;
40591 }
40592 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40593 return resultobj;
40594 fail:
40595 return NULL;
40596 }
40597
40598
40599 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40600 PyObject *resultobj = 0;
40601 wxMenu *arg1 = (wxMenu *) 0 ;
40602 PyObject *result = 0 ;
40603 void *argp1 = 0 ;
40604 int res1 = 0 ;
40605 PyObject *swig_obj[1] ;
40606
40607 if (!args) SWIG_fail;
40608 swig_obj[0] = args;
40609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40610 if (!SWIG_IsOK(res1)) {
40611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40612 }
40613 arg1 = reinterpret_cast< wxMenu * >(argp1);
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40617 wxPyEndAllowThreads(__tstate);
40618 if (PyErr_Occurred()) SWIG_fail;
40619 }
40620 resultobj = result;
40621 return resultobj;
40622 fail:
40623 return NULL;
40624 }
40625
40626
40627 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40628 PyObject *resultobj = 0;
40629 wxMenu *arg1 = (wxMenu *) 0 ;
40630 wxString *arg2 = 0 ;
40631 int result;
40632 void *argp1 = 0 ;
40633 int res1 = 0 ;
40634 bool temp2 = false ;
40635 PyObject * obj0 = 0 ;
40636 PyObject * obj1 = 0 ;
40637 char * kwnames[] = {
40638 (char *) "self",(char *) "item", NULL
40639 };
40640
40641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40643 if (!SWIG_IsOK(res1)) {
40644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40645 }
40646 arg1 = reinterpret_cast< wxMenu * >(argp1);
40647 {
40648 arg2 = wxString_in_helper(obj1);
40649 if (arg2 == NULL) SWIG_fail;
40650 temp2 = true;
40651 }
40652 {
40653 PyThreadState* __tstate = wxPyBeginAllowThreads();
40654 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40655 wxPyEndAllowThreads(__tstate);
40656 if (PyErr_Occurred()) SWIG_fail;
40657 }
40658 resultobj = SWIG_From_int(static_cast< int >(result));
40659 {
40660 if (temp2)
40661 delete arg2;
40662 }
40663 return resultobj;
40664 fail:
40665 {
40666 if (temp2)
40667 delete arg2;
40668 }
40669 return NULL;
40670 }
40671
40672
40673 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40674 PyObject *resultobj = 0;
40675 wxMenu *arg1 = (wxMenu *) 0 ;
40676 int arg2 ;
40677 wxMenuItem *result = 0 ;
40678 void *argp1 = 0 ;
40679 int res1 = 0 ;
40680 int val2 ;
40681 int ecode2 = 0 ;
40682 PyObject * obj0 = 0 ;
40683 PyObject * obj1 = 0 ;
40684 char * kwnames[] = {
40685 (char *) "self",(char *) "id", NULL
40686 };
40687
40688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40690 if (!SWIG_IsOK(res1)) {
40691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40692 }
40693 arg1 = reinterpret_cast< wxMenu * >(argp1);
40694 ecode2 = SWIG_AsVal_int(obj1, &val2);
40695 if (!SWIG_IsOK(ecode2)) {
40696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40697 }
40698 arg2 = static_cast< int >(val2);
40699 {
40700 PyThreadState* __tstate = wxPyBeginAllowThreads();
40701 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 {
40706 resultobj = wxPyMake_wxObject(result, (bool)0);
40707 }
40708 return resultobj;
40709 fail:
40710 return NULL;
40711 }
40712
40713
40714 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40715 PyObject *resultobj = 0;
40716 wxMenu *arg1 = (wxMenu *) 0 ;
40717 size_t arg2 ;
40718 wxMenuItem *result = 0 ;
40719 void *argp1 = 0 ;
40720 int res1 = 0 ;
40721 size_t val2 ;
40722 int ecode2 = 0 ;
40723 PyObject * obj0 = 0 ;
40724 PyObject * obj1 = 0 ;
40725 char * kwnames[] = {
40726 (char *) "self",(char *) "position", NULL
40727 };
40728
40729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40731 if (!SWIG_IsOK(res1)) {
40732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40733 }
40734 arg1 = reinterpret_cast< wxMenu * >(argp1);
40735 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40736 if (!SWIG_IsOK(ecode2)) {
40737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40738 }
40739 arg2 = static_cast< size_t >(val2);
40740 {
40741 PyThreadState* __tstate = wxPyBeginAllowThreads();
40742 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40743 wxPyEndAllowThreads(__tstate);
40744 if (PyErr_Occurred()) SWIG_fail;
40745 }
40746 {
40747 resultobj = wxPyMake_wxObject(result, (bool)0);
40748 }
40749 return resultobj;
40750 fail:
40751 return NULL;
40752 }
40753
40754
40755 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40756 PyObject *resultobj = 0;
40757 wxMenu *arg1 = (wxMenu *) 0 ;
40758 int arg2 ;
40759 bool arg3 ;
40760 void *argp1 = 0 ;
40761 int res1 = 0 ;
40762 int val2 ;
40763 int ecode2 = 0 ;
40764 bool val3 ;
40765 int ecode3 = 0 ;
40766 PyObject * obj0 = 0 ;
40767 PyObject * obj1 = 0 ;
40768 PyObject * obj2 = 0 ;
40769 char * kwnames[] = {
40770 (char *) "self",(char *) "id",(char *) "enable", NULL
40771 };
40772
40773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40775 if (!SWIG_IsOK(res1)) {
40776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40777 }
40778 arg1 = reinterpret_cast< wxMenu * >(argp1);
40779 ecode2 = SWIG_AsVal_int(obj1, &val2);
40780 if (!SWIG_IsOK(ecode2)) {
40781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40782 }
40783 arg2 = static_cast< int >(val2);
40784 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40785 if (!SWIG_IsOK(ecode3)) {
40786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40787 }
40788 arg3 = static_cast< bool >(val3);
40789 {
40790 PyThreadState* __tstate = wxPyBeginAllowThreads();
40791 (arg1)->Enable(arg2,arg3);
40792 wxPyEndAllowThreads(__tstate);
40793 if (PyErr_Occurred()) SWIG_fail;
40794 }
40795 resultobj = SWIG_Py_Void();
40796 return resultobj;
40797 fail:
40798 return NULL;
40799 }
40800
40801
40802 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40803 PyObject *resultobj = 0;
40804 wxMenu *arg1 = (wxMenu *) 0 ;
40805 int arg2 ;
40806 bool result;
40807 void *argp1 = 0 ;
40808 int res1 = 0 ;
40809 int val2 ;
40810 int ecode2 = 0 ;
40811 PyObject * obj0 = 0 ;
40812 PyObject * obj1 = 0 ;
40813 char * kwnames[] = {
40814 (char *) "self",(char *) "id", NULL
40815 };
40816
40817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40819 if (!SWIG_IsOK(res1)) {
40820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40821 }
40822 arg1 = reinterpret_cast< wxMenu * >(argp1);
40823 ecode2 = SWIG_AsVal_int(obj1, &val2);
40824 if (!SWIG_IsOK(ecode2)) {
40825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40826 }
40827 arg2 = static_cast< int >(val2);
40828 {
40829 PyThreadState* __tstate = wxPyBeginAllowThreads();
40830 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40831 wxPyEndAllowThreads(__tstate);
40832 if (PyErr_Occurred()) SWIG_fail;
40833 }
40834 {
40835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40836 }
40837 return resultobj;
40838 fail:
40839 return NULL;
40840 }
40841
40842
40843 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40844 PyObject *resultobj = 0;
40845 wxMenu *arg1 = (wxMenu *) 0 ;
40846 int arg2 ;
40847 bool arg3 ;
40848 void *argp1 = 0 ;
40849 int res1 = 0 ;
40850 int val2 ;
40851 int ecode2 = 0 ;
40852 bool val3 ;
40853 int ecode3 = 0 ;
40854 PyObject * obj0 = 0 ;
40855 PyObject * obj1 = 0 ;
40856 PyObject * obj2 = 0 ;
40857 char * kwnames[] = {
40858 (char *) "self",(char *) "id",(char *) "check", NULL
40859 };
40860
40861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40863 if (!SWIG_IsOK(res1)) {
40864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40865 }
40866 arg1 = reinterpret_cast< wxMenu * >(argp1);
40867 ecode2 = SWIG_AsVal_int(obj1, &val2);
40868 if (!SWIG_IsOK(ecode2)) {
40869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40870 }
40871 arg2 = static_cast< int >(val2);
40872 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40873 if (!SWIG_IsOK(ecode3)) {
40874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40875 }
40876 arg3 = static_cast< bool >(val3);
40877 {
40878 PyThreadState* __tstate = wxPyBeginAllowThreads();
40879 (arg1)->Check(arg2,arg3);
40880 wxPyEndAllowThreads(__tstate);
40881 if (PyErr_Occurred()) SWIG_fail;
40882 }
40883 resultobj = SWIG_Py_Void();
40884 return resultobj;
40885 fail:
40886 return NULL;
40887 }
40888
40889
40890 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40891 PyObject *resultobj = 0;
40892 wxMenu *arg1 = (wxMenu *) 0 ;
40893 int arg2 ;
40894 bool result;
40895 void *argp1 = 0 ;
40896 int res1 = 0 ;
40897 int val2 ;
40898 int ecode2 = 0 ;
40899 PyObject * obj0 = 0 ;
40900 PyObject * obj1 = 0 ;
40901 char * kwnames[] = {
40902 (char *) "self",(char *) "id", NULL
40903 };
40904
40905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40907 if (!SWIG_IsOK(res1)) {
40908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40909 }
40910 arg1 = reinterpret_cast< wxMenu * >(argp1);
40911 ecode2 = SWIG_AsVal_int(obj1, &val2);
40912 if (!SWIG_IsOK(ecode2)) {
40913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40914 }
40915 arg2 = static_cast< int >(val2);
40916 {
40917 PyThreadState* __tstate = wxPyBeginAllowThreads();
40918 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40919 wxPyEndAllowThreads(__tstate);
40920 if (PyErr_Occurred()) SWIG_fail;
40921 }
40922 {
40923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40924 }
40925 return resultobj;
40926 fail:
40927 return NULL;
40928 }
40929
40930
40931 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40932 PyObject *resultobj = 0;
40933 wxMenu *arg1 = (wxMenu *) 0 ;
40934 int arg2 ;
40935 wxString *arg3 = 0 ;
40936 void *argp1 = 0 ;
40937 int res1 = 0 ;
40938 int val2 ;
40939 int ecode2 = 0 ;
40940 bool temp3 = false ;
40941 PyObject * obj0 = 0 ;
40942 PyObject * obj1 = 0 ;
40943 PyObject * obj2 = 0 ;
40944 char * kwnames[] = {
40945 (char *) "self",(char *) "id",(char *) "label", NULL
40946 };
40947
40948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40950 if (!SWIG_IsOK(res1)) {
40951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40952 }
40953 arg1 = reinterpret_cast< wxMenu * >(argp1);
40954 ecode2 = SWIG_AsVal_int(obj1, &val2);
40955 if (!SWIG_IsOK(ecode2)) {
40956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40957 }
40958 arg2 = static_cast< int >(val2);
40959 {
40960 arg3 = wxString_in_helper(obj2);
40961 if (arg3 == NULL) SWIG_fail;
40962 temp3 = true;
40963 }
40964 {
40965 PyThreadState* __tstate = wxPyBeginAllowThreads();
40966 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40967 wxPyEndAllowThreads(__tstate);
40968 if (PyErr_Occurred()) SWIG_fail;
40969 }
40970 resultobj = SWIG_Py_Void();
40971 {
40972 if (temp3)
40973 delete arg3;
40974 }
40975 return resultobj;
40976 fail:
40977 {
40978 if (temp3)
40979 delete arg3;
40980 }
40981 return NULL;
40982 }
40983
40984
40985 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40986 PyObject *resultobj = 0;
40987 wxMenu *arg1 = (wxMenu *) 0 ;
40988 int arg2 ;
40989 wxString result;
40990 void *argp1 = 0 ;
40991 int res1 = 0 ;
40992 int val2 ;
40993 int ecode2 = 0 ;
40994 PyObject * obj0 = 0 ;
40995 PyObject * obj1 = 0 ;
40996 char * kwnames[] = {
40997 (char *) "self",(char *) "id", NULL
40998 };
40999
41000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41002 if (!SWIG_IsOK(res1)) {
41003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41004 }
41005 arg1 = reinterpret_cast< wxMenu * >(argp1);
41006 ecode2 = SWIG_AsVal_int(obj1, &val2);
41007 if (!SWIG_IsOK(ecode2)) {
41008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41009 }
41010 arg2 = static_cast< int >(val2);
41011 {
41012 PyThreadState* __tstate = wxPyBeginAllowThreads();
41013 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41014 wxPyEndAllowThreads(__tstate);
41015 if (PyErr_Occurred()) SWIG_fail;
41016 }
41017 {
41018 #if wxUSE_UNICODE
41019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41020 #else
41021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41022 #endif
41023 }
41024 return resultobj;
41025 fail:
41026 return NULL;
41027 }
41028
41029
41030 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41031 PyObject *resultobj = 0;
41032 wxMenu *arg1 = (wxMenu *) 0 ;
41033 int arg2 ;
41034 wxString *arg3 = 0 ;
41035 void *argp1 = 0 ;
41036 int res1 = 0 ;
41037 int val2 ;
41038 int ecode2 = 0 ;
41039 bool temp3 = false ;
41040 PyObject * obj0 = 0 ;
41041 PyObject * obj1 = 0 ;
41042 PyObject * obj2 = 0 ;
41043 char * kwnames[] = {
41044 (char *) "self",(char *) "id",(char *) "helpString", NULL
41045 };
41046
41047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41049 if (!SWIG_IsOK(res1)) {
41050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41051 }
41052 arg1 = reinterpret_cast< wxMenu * >(argp1);
41053 ecode2 = SWIG_AsVal_int(obj1, &val2);
41054 if (!SWIG_IsOK(ecode2)) {
41055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41056 }
41057 arg2 = static_cast< int >(val2);
41058 {
41059 arg3 = wxString_in_helper(obj2);
41060 if (arg3 == NULL) SWIG_fail;
41061 temp3 = true;
41062 }
41063 {
41064 PyThreadState* __tstate = wxPyBeginAllowThreads();
41065 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41066 wxPyEndAllowThreads(__tstate);
41067 if (PyErr_Occurred()) SWIG_fail;
41068 }
41069 resultobj = SWIG_Py_Void();
41070 {
41071 if (temp3)
41072 delete arg3;
41073 }
41074 return resultobj;
41075 fail:
41076 {
41077 if (temp3)
41078 delete arg3;
41079 }
41080 return NULL;
41081 }
41082
41083
41084 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41085 PyObject *resultobj = 0;
41086 wxMenu *arg1 = (wxMenu *) 0 ;
41087 int arg2 ;
41088 wxString result;
41089 void *argp1 = 0 ;
41090 int res1 = 0 ;
41091 int val2 ;
41092 int ecode2 = 0 ;
41093 PyObject * obj0 = 0 ;
41094 PyObject * obj1 = 0 ;
41095 char * kwnames[] = {
41096 (char *) "self",(char *) "id", NULL
41097 };
41098
41099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41101 if (!SWIG_IsOK(res1)) {
41102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41103 }
41104 arg1 = reinterpret_cast< wxMenu * >(argp1);
41105 ecode2 = SWIG_AsVal_int(obj1, &val2);
41106 if (!SWIG_IsOK(ecode2)) {
41107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41108 }
41109 arg2 = static_cast< int >(val2);
41110 {
41111 PyThreadState* __tstate = wxPyBeginAllowThreads();
41112 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41113 wxPyEndAllowThreads(__tstate);
41114 if (PyErr_Occurred()) SWIG_fail;
41115 }
41116 {
41117 #if wxUSE_UNICODE
41118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41119 #else
41120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41121 #endif
41122 }
41123 return resultobj;
41124 fail:
41125 return NULL;
41126 }
41127
41128
41129 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41130 PyObject *resultobj = 0;
41131 wxMenu *arg1 = (wxMenu *) 0 ;
41132 wxString *arg2 = 0 ;
41133 void *argp1 = 0 ;
41134 int res1 = 0 ;
41135 bool temp2 = false ;
41136 PyObject * obj0 = 0 ;
41137 PyObject * obj1 = 0 ;
41138 char * kwnames[] = {
41139 (char *) "self",(char *) "title", NULL
41140 };
41141
41142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41144 if (!SWIG_IsOK(res1)) {
41145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41146 }
41147 arg1 = reinterpret_cast< wxMenu * >(argp1);
41148 {
41149 arg2 = wxString_in_helper(obj1);
41150 if (arg2 == NULL) SWIG_fail;
41151 temp2 = true;
41152 }
41153 {
41154 PyThreadState* __tstate = wxPyBeginAllowThreads();
41155 (arg1)->SetTitle((wxString const &)*arg2);
41156 wxPyEndAllowThreads(__tstate);
41157 if (PyErr_Occurred()) SWIG_fail;
41158 }
41159 resultobj = SWIG_Py_Void();
41160 {
41161 if (temp2)
41162 delete arg2;
41163 }
41164 return resultobj;
41165 fail:
41166 {
41167 if (temp2)
41168 delete arg2;
41169 }
41170 return NULL;
41171 }
41172
41173
41174 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41175 PyObject *resultobj = 0;
41176 wxMenu *arg1 = (wxMenu *) 0 ;
41177 wxString result;
41178 void *argp1 = 0 ;
41179 int res1 = 0 ;
41180 PyObject *swig_obj[1] ;
41181
41182 if (!args) SWIG_fail;
41183 swig_obj[0] = args;
41184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41185 if (!SWIG_IsOK(res1)) {
41186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41187 }
41188 arg1 = reinterpret_cast< wxMenu * >(argp1);
41189 {
41190 PyThreadState* __tstate = wxPyBeginAllowThreads();
41191 result = ((wxMenu const *)arg1)->GetTitle();
41192 wxPyEndAllowThreads(__tstate);
41193 if (PyErr_Occurred()) SWIG_fail;
41194 }
41195 {
41196 #if wxUSE_UNICODE
41197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41198 #else
41199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41200 #endif
41201 }
41202 return resultobj;
41203 fail:
41204 return NULL;
41205 }
41206
41207
41208 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41209 PyObject *resultobj = 0;
41210 wxMenu *arg1 = (wxMenu *) 0 ;
41211 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41212 void *argp1 = 0 ;
41213 int res1 = 0 ;
41214 void *argp2 = 0 ;
41215 int res2 = 0 ;
41216 PyObject * obj0 = 0 ;
41217 PyObject * obj1 = 0 ;
41218 char * kwnames[] = {
41219 (char *) "self",(char *) "handler", NULL
41220 };
41221
41222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41224 if (!SWIG_IsOK(res1)) {
41225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41226 }
41227 arg1 = reinterpret_cast< wxMenu * >(argp1);
41228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41229 if (!SWIG_IsOK(res2)) {
41230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41231 }
41232 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41233 {
41234 PyThreadState* __tstate = wxPyBeginAllowThreads();
41235 (arg1)->SetEventHandler(arg2);
41236 wxPyEndAllowThreads(__tstate);
41237 if (PyErr_Occurred()) SWIG_fail;
41238 }
41239 resultobj = SWIG_Py_Void();
41240 return resultobj;
41241 fail:
41242 return NULL;
41243 }
41244
41245
41246 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41247 PyObject *resultobj = 0;
41248 wxMenu *arg1 = (wxMenu *) 0 ;
41249 wxEvtHandler *result = 0 ;
41250 void *argp1 = 0 ;
41251 int res1 = 0 ;
41252 PyObject *swig_obj[1] ;
41253
41254 if (!args) SWIG_fail;
41255 swig_obj[0] = args;
41256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41257 if (!SWIG_IsOK(res1)) {
41258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41259 }
41260 arg1 = reinterpret_cast< wxMenu * >(argp1);
41261 {
41262 PyThreadState* __tstate = wxPyBeginAllowThreads();
41263 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41264 wxPyEndAllowThreads(__tstate);
41265 if (PyErr_Occurred()) SWIG_fail;
41266 }
41267 {
41268 resultobj = wxPyMake_wxObject(result, 0);
41269 }
41270 return resultobj;
41271 fail:
41272 return NULL;
41273 }
41274
41275
41276 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41277 PyObject *resultobj = 0;
41278 wxMenu *arg1 = (wxMenu *) 0 ;
41279 wxWindow *arg2 = (wxWindow *) 0 ;
41280 void *argp1 = 0 ;
41281 int res1 = 0 ;
41282 void *argp2 = 0 ;
41283 int res2 = 0 ;
41284 PyObject * obj0 = 0 ;
41285 PyObject * obj1 = 0 ;
41286 char * kwnames[] = {
41287 (char *) "self",(char *) "win", NULL
41288 };
41289
41290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41292 if (!SWIG_IsOK(res1)) {
41293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41294 }
41295 arg1 = reinterpret_cast< wxMenu * >(argp1);
41296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41297 if (!SWIG_IsOK(res2)) {
41298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41299 }
41300 arg2 = reinterpret_cast< wxWindow * >(argp2);
41301 {
41302 PyThreadState* __tstate = wxPyBeginAllowThreads();
41303 (arg1)->SetInvokingWindow(arg2);
41304 wxPyEndAllowThreads(__tstate);
41305 if (PyErr_Occurred()) SWIG_fail;
41306 }
41307 resultobj = SWIG_Py_Void();
41308 return resultobj;
41309 fail:
41310 return NULL;
41311 }
41312
41313
41314 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41315 PyObject *resultobj = 0;
41316 wxMenu *arg1 = (wxMenu *) 0 ;
41317 wxWindow *result = 0 ;
41318 void *argp1 = 0 ;
41319 int res1 = 0 ;
41320 PyObject *swig_obj[1] ;
41321
41322 if (!args) SWIG_fail;
41323 swig_obj[0] = args;
41324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41325 if (!SWIG_IsOK(res1)) {
41326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41327 }
41328 arg1 = reinterpret_cast< wxMenu * >(argp1);
41329 {
41330 PyThreadState* __tstate = wxPyBeginAllowThreads();
41331 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41332 wxPyEndAllowThreads(__tstate);
41333 if (PyErr_Occurred()) SWIG_fail;
41334 }
41335 {
41336 resultobj = wxPyMake_wxObject(result, 0);
41337 }
41338 return resultobj;
41339 fail:
41340 return NULL;
41341 }
41342
41343
41344 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41345 PyObject *resultobj = 0;
41346 wxMenu *arg1 = (wxMenu *) 0 ;
41347 long result;
41348 void *argp1 = 0 ;
41349 int res1 = 0 ;
41350 PyObject *swig_obj[1] ;
41351
41352 if (!args) SWIG_fail;
41353 swig_obj[0] = args;
41354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41355 if (!SWIG_IsOK(res1)) {
41356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41357 }
41358 arg1 = reinterpret_cast< wxMenu * >(argp1);
41359 {
41360 PyThreadState* __tstate = wxPyBeginAllowThreads();
41361 result = (long)((wxMenu const *)arg1)->GetStyle();
41362 wxPyEndAllowThreads(__tstate);
41363 if (PyErr_Occurred()) SWIG_fail;
41364 }
41365 resultobj = SWIG_From_long(static_cast< long >(result));
41366 return resultobj;
41367 fail:
41368 return NULL;
41369 }
41370
41371
41372 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41373 PyObject *resultobj = 0;
41374 wxMenu *arg1 = (wxMenu *) 0 ;
41375 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41376 void *argp1 = 0 ;
41377 int res1 = 0 ;
41378 void *argp2 = 0 ;
41379 int res2 = 0 ;
41380 PyObject * obj0 = 0 ;
41381 PyObject * obj1 = 0 ;
41382 char * kwnames[] = {
41383 (char *) "self",(char *) "source", NULL
41384 };
41385
41386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41388 if (!SWIG_IsOK(res1)) {
41389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41390 }
41391 arg1 = reinterpret_cast< wxMenu * >(argp1);
41392 if (obj1) {
41393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41394 if (!SWIG_IsOK(res2)) {
41395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41396 }
41397 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41398 }
41399 {
41400 PyThreadState* __tstate = wxPyBeginAllowThreads();
41401 (arg1)->UpdateUI(arg2);
41402 wxPyEndAllowThreads(__tstate);
41403 if (PyErr_Occurred()) SWIG_fail;
41404 }
41405 resultobj = SWIG_Py_Void();
41406 return resultobj;
41407 fail:
41408 return NULL;
41409 }
41410
41411
41412 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41413 PyObject *resultobj = 0;
41414 wxMenu *arg1 = (wxMenu *) 0 ;
41415 wxMenuBar *result = 0 ;
41416 void *argp1 = 0 ;
41417 int res1 = 0 ;
41418 PyObject *swig_obj[1] ;
41419
41420 if (!args) SWIG_fail;
41421 swig_obj[0] = args;
41422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41423 if (!SWIG_IsOK(res1)) {
41424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41425 }
41426 arg1 = reinterpret_cast< wxMenu * >(argp1);
41427 {
41428 PyThreadState* __tstate = wxPyBeginAllowThreads();
41429 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41430 wxPyEndAllowThreads(__tstate);
41431 if (PyErr_Occurred()) SWIG_fail;
41432 }
41433 {
41434 resultobj = wxPyMake_wxObject(result, (bool)0);
41435 }
41436 return resultobj;
41437 fail:
41438 return NULL;
41439 }
41440
41441
41442 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41443 PyObject *resultobj = 0;
41444 wxMenu *arg1 = (wxMenu *) 0 ;
41445 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41446 void *argp1 = 0 ;
41447 int res1 = 0 ;
41448 void *argp2 = 0 ;
41449 int res2 = 0 ;
41450 PyObject * obj0 = 0 ;
41451 PyObject * obj1 = 0 ;
41452 char * kwnames[] = {
41453 (char *) "self",(char *) "menubar", NULL
41454 };
41455
41456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41458 if (!SWIG_IsOK(res1)) {
41459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41460 }
41461 arg1 = reinterpret_cast< wxMenu * >(argp1);
41462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41463 if (!SWIG_IsOK(res2)) {
41464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41465 }
41466 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 (arg1)->Attach(arg2);
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 resultobj = SWIG_Py_Void();
41474 return resultobj;
41475 fail:
41476 return NULL;
41477 }
41478
41479
41480 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41481 PyObject *resultobj = 0;
41482 wxMenu *arg1 = (wxMenu *) 0 ;
41483 void *argp1 = 0 ;
41484 int res1 = 0 ;
41485 PyObject *swig_obj[1] ;
41486
41487 if (!args) SWIG_fail;
41488 swig_obj[0] = args;
41489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41490 if (!SWIG_IsOK(res1)) {
41491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41492 }
41493 arg1 = reinterpret_cast< wxMenu * >(argp1);
41494 {
41495 PyThreadState* __tstate = wxPyBeginAllowThreads();
41496 (arg1)->Detach();
41497 wxPyEndAllowThreads(__tstate);
41498 if (PyErr_Occurred()) SWIG_fail;
41499 }
41500 resultobj = SWIG_Py_Void();
41501 return resultobj;
41502 fail:
41503 return NULL;
41504 }
41505
41506
41507 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41508 PyObject *resultobj = 0;
41509 wxMenu *arg1 = (wxMenu *) 0 ;
41510 bool result;
41511 void *argp1 = 0 ;
41512 int res1 = 0 ;
41513 PyObject *swig_obj[1] ;
41514
41515 if (!args) SWIG_fail;
41516 swig_obj[0] = args;
41517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41518 if (!SWIG_IsOK(res1)) {
41519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41520 }
41521 arg1 = reinterpret_cast< wxMenu * >(argp1);
41522 {
41523 PyThreadState* __tstate = wxPyBeginAllowThreads();
41524 result = (bool)((wxMenu const *)arg1)->IsAttached();
41525 wxPyEndAllowThreads(__tstate);
41526 if (PyErr_Occurred()) SWIG_fail;
41527 }
41528 {
41529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41530 }
41531 return resultobj;
41532 fail:
41533 return NULL;
41534 }
41535
41536
41537 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41538 PyObject *resultobj = 0;
41539 wxMenu *arg1 = (wxMenu *) 0 ;
41540 wxMenu *arg2 = (wxMenu *) 0 ;
41541 void *argp1 = 0 ;
41542 int res1 = 0 ;
41543 void *argp2 = 0 ;
41544 int res2 = 0 ;
41545 PyObject * obj0 = 0 ;
41546 PyObject * obj1 = 0 ;
41547 char * kwnames[] = {
41548 (char *) "self",(char *) "parent", NULL
41549 };
41550
41551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41553 if (!SWIG_IsOK(res1)) {
41554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41555 }
41556 arg1 = reinterpret_cast< wxMenu * >(argp1);
41557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41558 if (!SWIG_IsOK(res2)) {
41559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41560 }
41561 arg2 = reinterpret_cast< wxMenu * >(argp2);
41562 {
41563 PyThreadState* __tstate = wxPyBeginAllowThreads();
41564 (arg1)->SetParent(arg2);
41565 wxPyEndAllowThreads(__tstate);
41566 if (PyErr_Occurred()) SWIG_fail;
41567 }
41568 resultobj = SWIG_Py_Void();
41569 return resultobj;
41570 fail:
41571 return NULL;
41572 }
41573
41574
41575 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41576 PyObject *resultobj = 0;
41577 wxMenu *arg1 = (wxMenu *) 0 ;
41578 wxMenu *result = 0 ;
41579 void *argp1 = 0 ;
41580 int res1 = 0 ;
41581 PyObject *swig_obj[1] ;
41582
41583 if (!args) SWIG_fail;
41584 swig_obj[0] = args;
41585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41586 if (!SWIG_IsOK(res1)) {
41587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41588 }
41589 arg1 = reinterpret_cast< wxMenu * >(argp1);
41590 {
41591 PyThreadState* __tstate = wxPyBeginAllowThreads();
41592 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41593 wxPyEndAllowThreads(__tstate);
41594 if (PyErr_Occurred()) SWIG_fail;
41595 }
41596 {
41597 resultobj = wxPyMake_wxObject(result, 0);
41598 }
41599 return resultobj;
41600 fail:
41601 return NULL;
41602 }
41603
41604
41605 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41606 PyObject *obj;
41607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41608 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41609 return SWIG_Py_Void();
41610 }
41611
41612 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41613 return SWIG_Python_InitShadowInstance(args);
41614 }
41615
41616 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41617 PyObject *resultobj = 0;
41618 long arg1 = (long) 0 ;
41619 wxMenuBar *result = 0 ;
41620 long val1 ;
41621 int ecode1 = 0 ;
41622 PyObject * obj0 = 0 ;
41623 char * kwnames[] = {
41624 (char *) "style", NULL
41625 };
41626
41627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41628 if (obj0) {
41629 ecode1 = SWIG_AsVal_long(obj0, &val1);
41630 if (!SWIG_IsOK(ecode1)) {
41631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41632 }
41633 arg1 = static_cast< long >(val1);
41634 }
41635 {
41636 if (!wxPyCheckForApp()) SWIG_fail;
41637 PyThreadState* __tstate = wxPyBeginAllowThreads();
41638 result = (wxMenuBar *)new wxMenuBar(arg1);
41639 wxPyEndAllowThreads(__tstate);
41640 if (PyErr_Occurred()) SWIG_fail;
41641 }
41642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41643 return resultobj;
41644 fail:
41645 return NULL;
41646 }
41647
41648
41649 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41650 PyObject *resultobj = 0;
41651 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41652 wxMenu *arg2 = (wxMenu *) 0 ;
41653 wxString *arg3 = 0 ;
41654 bool result;
41655 void *argp1 = 0 ;
41656 int res1 = 0 ;
41657 void *argp2 = 0 ;
41658 int res2 = 0 ;
41659 bool temp3 = false ;
41660 PyObject * obj0 = 0 ;
41661 PyObject * obj1 = 0 ;
41662 PyObject * obj2 = 0 ;
41663 char * kwnames[] = {
41664 (char *) "self",(char *) "menu",(char *) "title", NULL
41665 };
41666
41667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41669 if (!SWIG_IsOK(res1)) {
41670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41671 }
41672 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41674 if (!SWIG_IsOK(res2)) {
41675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41676 }
41677 arg2 = reinterpret_cast< wxMenu * >(argp2);
41678 {
41679 arg3 = wxString_in_helper(obj2);
41680 if (arg3 == NULL) SWIG_fail;
41681 temp3 = true;
41682 }
41683 {
41684 PyThreadState* __tstate = wxPyBeginAllowThreads();
41685 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41686 wxPyEndAllowThreads(__tstate);
41687 if (PyErr_Occurred()) SWIG_fail;
41688 }
41689 {
41690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41691 }
41692 {
41693 if (temp3)
41694 delete arg3;
41695 }
41696 return resultobj;
41697 fail:
41698 {
41699 if (temp3)
41700 delete arg3;
41701 }
41702 return NULL;
41703 }
41704
41705
41706 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41707 PyObject *resultobj = 0;
41708 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41709 size_t arg2 ;
41710 wxMenu *arg3 = (wxMenu *) 0 ;
41711 wxString *arg4 = 0 ;
41712 bool result;
41713 void *argp1 = 0 ;
41714 int res1 = 0 ;
41715 size_t val2 ;
41716 int ecode2 = 0 ;
41717 void *argp3 = 0 ;
41718 int res3 = 0 ;
41719 bool temp4 = false ;
41720 PyObject * obj0 = 0 ;
41721 PyObject * obj1 = 0 ;
41722 PyObject * obj2 = 0 ;
41723 PyObject * obj3 = 0 ;
41724 char * kwnames[] = {
41725 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41726 };
41727
41728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41730 if (!SWIG_IsOK(res1)) {
41731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41732 }
41733 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41734 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41735 if (!SWIG_IsOK(ecode2)) {
41736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41737 }
41738 arg2 = static_cast< size_t >(val2);
41739 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41740 if (!SWIG_IsOK(res3)) {
41741 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41742 }
41743 arg3 = reinterpret_cast< wxMenu * >(argp3);
41744 {
41745 arg4 = wxString_in_helper(obj3);
41746 if (arg4 == NULL) SWIG_fail;
41747 temp4 = true;
41748 }
41749 {
41750 PyThreadState* __tstate = wxPyBeginAllowThreads();
41751 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 {
41756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41757 }
41758 {
41759 if (temp4)
41760 delete arg4;
41761 }
41762 return resultobj;
41763 fail:
41764 {
41765 if (temp4)
41766 delete arg4;
41767 }
41768 return NULL;
41769 }
41770
41771
41772 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41773 PyObject *resultobj = 0;
41774 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41775 size_t result;
41776 void *argp1 = 0 ;
41777 int res1 = 0 ;
41778 PyObject *swig_obj[1] ;
41779
41780 if (!args) SWIG_fail;
41781 swig_obj[0] = args;
41782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41783 if (!SWIG_IsOK(res1)) {
41784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41785 }
41786 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41787 {
41788 PyThreadState* __tstate = wxPyBeginAllowThreads();
41789 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41790 wxPyEndAllowThreads(__tstate);
41791 if (PyErr_Occurred()) SWIG_fail;
41792 }
41793 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41794 return resultobj;
41795 fail:
41796 return NULL;
41797 }
41798
41799
41800 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41801 PyObject *resultobj = 0;
41802 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41803 size_t arg2 ;
41804 wxMenu *result = 0 ;
41805 void *argp1 = 0 ;
41806 int res1 = 0 ;
41807 size_t val2 ;
41808 int ecode2 = 0 ;
41809 PyObject * obj0 = 0 ;
41810 PyObject * obj1 = 0 ;
41811 char * kwnames[] = {
41812 (char *) "self",(char *) "pos", NULL
41813 };
41814
41815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41817 if (!SWIG_IsOK(res1)) {
41818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41819 }
41820 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41821 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41822 if (!SWIG_IsOK(ecode2)) {
41823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41824 }
41825 arg2 = static_cast< size_t >(val2);
41826 {
41827 PyThreadState* __tstate = wxPyBeginAllowThreads();
41828 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41829 wxPyEndAllowThreads(__tstate);
41830 if (PyErr_Occurred()) SWIG_fail;
41831 }
41832 {
41833 resultobj = wxPyMake_wxObject(result, 0);
41834 }
41835 return resultobj;
41836 fail:
41837 return NULL;
41838 }
41839
41840
41841 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41842 PyObject *resultobj = 0;
41843 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41844 size_t arg2 ;
41845 wxMenu *arg3 = (wxMenu *) 0 ;
41846 wxString *arg4 = 0 ;
41847 wxMenu *result = 0 ;
41848 void *argp1 = 0 ;
41849 int res1 = 0 ;
41850 size_t val2 ;
41851 int ecode2 = 0 ;
41852 void *argp3 = 0 ;
41853 int res3 = 0 ;
41854 bool temp4 = false ;
41855 PyObject * obj0 = 0 ;
41856 PyObject * obj1 = 0 ;
41857 PyObject * obj2 = 0 ;
41858 PyObject * obj3 = 0 ;
41859 char * kwnames[] = {
41860 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41861 };
41862
41863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41865 if (!SWIG_IsOK(res1)) {
41866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41867 }
41868 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41869 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41870 if (!SWIG_IsOK(ecode2)) {
41871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41872 }
41873 arg2 = static_cast< size_t >(val2);
41874 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41875 if (!SWIG_IsOK(res3)) {
41876 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41877 }
41878 arg3 = reinterpret_cast< wxMenu * >(argp3);
41879 {
41880 arg4 = wxString_in_helper(obj3);
41881 if (arg4 == NULL) SWIG_fail;
41882 temp4 = true;
41883 }
41884 {
41885 PyThreadState* __tstate = wxPyBeginAllowThreads();
41886 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41887 wxPyEndAllowThreads(__tstate);
41888 if (PyErr_Occurred()) SWIG_fail;
41889 }
41890 {
41891 resultobj = wxPyMake_wxObject(result, 0);
41892 }
41893 {
41894 if (temp4)
41895 delete arg4;
41896 }
41897 return resultobj;
41898 fail:
41899 {
41900 if (temp4)
41901 delete arg4;
41902 }
41903 return NULL;
41904 }
41905
41906
41907 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41908 PyObject *resultobj = 0;
41909 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41910 size_t arg2 ;
41911 wxMenu *result = 0 ;
41912 void *argp1 = 0 ;
41913 int res1 = 0 ;
41914 size_t val2 ;
41915 int ecode2 = 0 ;
41916 PyObject * obj0 = 0 ;
41917 PyObject * obj1 = 0 ;
41918 char * kwnames[] = {
41919 (char *) "self",(char *) "pos", NULL
41920 };
41921
41922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41924 if (!SWIG_IsOK(res1)) {
41925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41926 }
41927 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41928 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41929 if (!SWIG_IsOK(ecode2)) {
41930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41931 }
41932 arg2 = static_cast< size_t >(val2);
41933 {
41934 PyThreadState* __tstate = wxPyBeginAllowThreads();
41935 result = (wxMenu *)(arg1)->Remove(arg2);
41936 wxPyEndAllowThreads(__tstate);
41937 if (PyErr_Occurred()) SWIG_fail;
41938 }
41939 {
41940 resultobj = wxPyMake_wxObject(result, 0);
41941 }
41942 return resultobj;
41943 fail:
41944 return NULL;
41945 }
41946
41947
41948 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41949 PyObject *resultobj = 0;
41950 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41951 size_t arg2 ;
41952 bool arg3 ;
41953 void *argp1 = 0 ;
41954 int res1 = 0 ;
41955 size_t val2 ;
41956 int ecode2 = 0 ;
41957 bool val3 ;
41958 int ecode3 = 0 ;
41959 PyObject * obj0 = 0 ;
41960 PyObject * obj1 = 0 ;
41961 PyObject * obj2 = 0 ;
41962 char * kwnames[] = {
41963 (char *) "self",(char *) "pos",(char *) "enable", NULL
41964 };
41965
41966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41968 if (!SWIG_IsOK(res1)) {
41969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41970 }
41971 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41972 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41973 if (!SWIG_IsOK(ecode2)) {
41974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41975 }
41976 arg2 = static_cast< size_t >(val2);
41977 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41978 if (!SWIG_IsOK(ecode3)) {
41979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41980 }
41981 arg3 = static_cast< bool >(val3);
41982 {
41983 PyThreadState* __tstate = wxPyBeginAllowThreads();
41984 (arg1)->EnableTop(arg2,arg3);
41985 wxPyEndAllowThreads(__tstate);
41986 if (PyErr_Occurred()) SWIG_fail;
41987 }
41988 resultobj = SWIG_Py_Void();
41989 return resultobj;
41990 fail:
41991 return NULL;
41992 }
41993
41994
41995 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41996 PyObject *resultobj = 0;
41997 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41998 size_t arg2 ;
41999 bool result;
42000 void *argp1 = 0 ;
42001 int res1 = 0 ;
42002 size_t val2 ;
42003 int ecode2 = 0 ;
42004 PyObject * obj0 = 0 ;
42005 PyObject * obj1 = 0 ;
42006 char * kwnames[] = {
42007 (char *) "self",(char *) "pos", NULL
42008 };
42009
42010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42012 if (!SWIG_IsOK(res1)) {
42013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42014 }
42015 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42016 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42017 if (!SWIG_IsOK(ecode2)) {
42018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42019 }
42020 arg2 = static_cast< size_t >(val2);
42021 {
42022 PyThreadState* __tstate = wxPyBeginAllowThreads();
42023 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42024 wxPyEndAllowThreads(__tstate);
42025 if (PyErr_Occurred()) SWIG_fail;
42026 }
42027 {
42028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42029 }
42030 return resultobj;
42031 fail:
42032 return NULL;
42033 }
42034
42035
42036 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42037 PyObject *resultobj = 0;
42038 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42039 size_t arg2 ;
42040 wxString *arg3 = 0 ;
42041 void *argp1 = 0 ;
42042 int res1 = 0 ;
42043 size_t val2 ;
42044 int ecode2 = 0 ;
42045 bool temp3 = false ;
42046 PyObject * obj0 = 0 ;
42047 PyObject * obj1 = 0 ;
42048 PyObject * obj2 = 0 ;
42049 char * kwnames[] = {
42050 (char *) "self",(char *) "pos",(char *) "label", NULL
42051 };
42052
42053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42055 if (!SWIG_IsOK(res1)) {
42056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42057 }
42058 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42059 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42060 if (!SWIG_IsOK(ecode2)) {
42061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42062 }
42063 arg2 = static_cast< size_t >(val2);
42064 {
42065 arg3 = wxString_in_helper(obj2);
42066 if (arg3 == NULL) SWIG_fail;
42067 temp3 = true;
42068 }
42069 {
42070 PyThreadState* __tstate = wxPyBeginAllowThreads();
42071 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42072 wxPyEndAllowThreads(__tstate);
42073 if (PyErr_Occurred()) SWIG_fail;
42074 }
42075 resultobj = SWIG_Py_Void();
42076 {
42077 if (temp3)
42078 delete arg3;
42079 }
42080 return resultobj;
42081 fail:
42082 {
42083 if (temp3)
42084 delete arg3;
42085 }
42086 return NULL;
42087 }
42088
42089
42090 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42091 PyObject *resultobj = 0;
42092 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42093 size_t arg2 ;
42094 wxString result;
42095 void *argp1 = 0 ;
42096 int res1 = 0 ;
42097 size_t val2 ;
42098 int ecode2 = 0 ;
42099 PyObject * obj0 = 0 ;
42100 PyObject * obj1 = 0 ;
42101 char * kwnames[] = {
42102 (char *) "self",(char *) "pos", NULL
42103 };
42104
42105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42107 if (!SWIG_IsOK(res1)) {
42108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42109 }
42110 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42111 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42112 if (!SWIG_IsOK(ecode2)) {
42113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42114 }
42115 arg2 = static_cast< size_t >(val2);
42116 {
42117 PyThreadState* __tstate = wxPyBeginAllowThreads();
42118 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42119 wxPyEndAllowThreads(__tstate);
42120 if (PyErr_Occurred()) SWIG_fail;
42121 }
42122 {
42123 #if wxUSE_UNICODE
42124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42125 #else
42126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42127 #endif
42128 }
42129 return resultobj;
42130 fail:
42131 return NULL;
42132 }
42133
42134
42135 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42136 PyObject *resultobj = 0;
42137 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42138 wxString *arg2 = 0 ;
42139 wxString *arg3 = 0 ;
42140 int result;
42141 void *argp1 = 0 ;
42142 int res1 = 0 ;
42143 bool temp2 = false ;
42144 bool temp3 = false ;
42145 PyObject * obj0 = 0 ;
42146 PyObject * obj1 = 0 ;
42147 PyObject * obj2 = 0 ;
42148 char * kwnames[] = {
42149 (char *) "self",(char *) "menu",(char *) "item", NULL
42150 };
42151
42152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42154 if (!SWIG_IsOK(res1)) {
42155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42156 }
42157 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42158 {
42159 arg2 = wxString_in_helper(obj1);
42160 if (arg2 == NULL) SWIG_fail;
42161 temp2 = true;
42162 }
42163 {
42164 arg3 = wxString_in_helper(obj2);
42165 if (arg3 == NULL) SWIG_fail;
42166 temp3 = true;
42167 }
42168 {
42169 PyThreadState* __tstate = wxPyBeginAllowThreads();
42170 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42171 wxPyEndAllowThreads(__tstate);
42172 if (PyErr_Occurred()) SWIG_fail;
42173 }
42174 resultobj = SWIG_From_int(static_cast< int >(result));
42175 {
42176 if (temp2)
42177 delete arg2;
42178 }
42179 {
42180 if (temp3)
42181 delete arg3;
42182 }
42183 return resultobj;
42184 fail:
42185 {
42186 if (temp2)
42187 delete arg2;
42188 }
42189 {
42190 if (temp3)
42191 delete arg3;
42192 }
42193 return NULL;
42194 }
42195
42196
42197 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42198 PyObject *resultobj = 0;
42199 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42200 int arg2 ;
42201 wxMenuItem *result = 0 ;
42202 void *argp1 = 0 ;
42203 int res1 = 0 ;
42204 int val2 ;
42205 int ecode2 = 0 ;
42206 PyObject * obj0 = 0 ;
42207 PyObject * obj1 = 0 ;
42208 char * kwnames[] = {
42209 (char *) "self",(char *) "id", NULL
42210 };
42211
42212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42214 if (!SWIG_IsOK(res1)) {
42215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42216 }
42217 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42218 ecode2 = SWIG_AsVal_int(obj1, &val2);
42219 if (!SWIG_IsOK(ecode2)) {
42220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42221 }
42222 arg2 = static_cast< int >(val2);
42223 {
42224 PyThreadState* __tstate = wxPyBeginAllowThreads();
42225 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42226 wxPyEndAllowThreads(__tstate);
42227 if (PyErr_Occurred()) SWIG_fail;
42228 }
42229 {
42230 resultobj = wxPyMake_wxObject(result, (bool)0);
42231 }
42232 return resultobj;
42233 fail:
42234 return NULL;
42235 }
42236
42237
42238 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42239 PyObject *resultobj = 0;
42240 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42241 wxString *arg2 = 0 ;
42242 int result;
42243 void *argp1 = 0 ;
42244 int res1 = 0 ;
42245 bool temp2 = false ;
42246 PyObject * obj0 = 0 ;
42247 PyObject * obj1 = 0 ;
42248 char * kwnames[] = {
42249 (char *) "self",(char *) "title", NULL
42250 };
42251
42252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42254 if (!SWIG_IsOK(res1)) {
42255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42256 }
42257 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42258 {
42259 arg2 = wxString_in_helper(obj1);
42260 if (arg2 == NULL) SWIG_fail;
42261 temp2 = true;
42262 }
42263 {
42264 PyThreadState* __tstate = wxPyBeginAllowThreads();
42265 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42266 wxPyEndAllowThreads(__tstate);
42267 if (PyErr_Occurred()) SWIG_fail;
42268 }
42269 resultobj = SWIG_From_int(static_cast< int >(result));
42270 {
42271 if (temp2)
42272 delete arg2;
42273 }
42274 return resultobj;
42275 fail:
42276 {
42277 if (temp2)
42278 delete arg2;
42279 }
42280 return NULL;
42281 }
42282
42283
42284 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42285 PyObject *resultobj = 0;
42286 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42287 int arg2 ;
42288 bool arg3 ;
42289 void *argp1 = 0 ;
42290 int res1 = 0 ;
42291 int val2 ;
42292 int ecode2 = 0 ;
42293 bool val3 ;
42294 int ecode3 = 0 ;
42295 PyObject * obj0 = 0 ;
42296 PyObject * obj1 = 0 ;
42297 PyObject * obj2 = 0 ;
42298 char * kwnames[] = {
42299 (char *) "self",(char *) "id",(char *) "enable", NULL
42300 };
42301
42302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42304 if (!SWIG_IsOK(res1)) {
42305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42306 }
42307 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42308 ecode2 = SWIG_AsVal_int(obj1, &val2);
42309 if (!SWIG_IsOK(ecode2)) {
42310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42311 }
42312 arg2 = static_cast< int >(val2);
42313 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42314 if (!SWIG_IsOK(ecode3)) {
42315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42316 }
42317 arg3 = static_cast< bool >(val3);
42318 {
42319 PyThreadState* __tstate = wxPyBeginAllowThreads();
42320 (arg1)->Enable(arg2,arg3);
42321 wxPyEndAllowThreads(__tstate);
42322 if (PyErr_Occurred()) SWIG_fail;
42323 }
42324 resultobj = SWIG_Py_Void();
42325 return resultobj;
42326 fail:
42327 return NULL;
42328 }
42329
42330
42331 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42332 PyObject *resultobj = 0;
42333 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42334 int arg2 ;
42335 bool arg3 ;
42336 void *argp1 = 0 ;
42337 int res1 = 0 ;
42338 int val2 ;
42339 int ecode2 = 0 ;
42340 bool val3 ;
42341 int ecode3 = 0 ;
42342 PyObject * obj0 = 0 ;
42343 PyObject * obj1 = 0 ;
42344 PyObject * obj2 = 0 ;
42345 char * kwnames[] = {
42346 (char *) "self",(char *) "id",(char *) "check", NULL
42347 };
42348
42349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42351 if (!SWIG_IsOK(res1)) {
42352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42353 }
42354 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42355 ecode2 = SWIG_AsVal_int(obj1, &val2);
42356 if (!SWIG_IsOK(ecode2)) {
42357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42358 }
42359 arg2 = static_cast< int >(val2);
42360 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42361 if (!SWIG_IsOK(ecode3)) {
42362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42363 }
42364 arg3 = static_cast< bool >(val3);
42365 {
42366 PyThreadState* __tstate = wxPyBeginAllowThreads();
42367 (arg1)->Check(arg2,arg3);
42368 wxPyEndAllowThreads(__tstate);
42369 if (PyErr_Occurred()) SWIG_fail;
42370 }
42371 resultobj = SWIG_Py_Void();
42372 return resultobj;
42373 fail:
42374 return NULL;
42375 }
42376
42377
42378 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42379 PyObject *resultobj = 0;
42380 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42381 int arg2 ;
42382 bool result;
42383 void *argp1 = 0 ;
42384 int res1 = 0 ;
42385 int val2 ;
42386 int ecode2 = 0 ;
42387 PyObject * obj0 = 0 ;
42388 PyObject * obj1 = 0 ;
42389 char * kwnames[] = {
42390 (char *) "self",(char *) "id", NULL
42391 };
42392
42393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42395 if (!SWIG_IsOK(res1)) {
42396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42397 }
42398 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42399 ecode2 = SWIG_AsVal_int(obj1, &val2);
42400 if (!SWIG_IsOK(ecode2)) {
42401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42402 }
42403 arg2 = static_cast< int >(val2);
42404 {
42405 PyThreadState* __tstate = wxPyBeginAllowThreads();
42406 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42407 wxPyEndAllowThreads(__tstate);
42408 if (PyErr_Occurred()) SWIG_fail;
42409 }
42410 {
42411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42412 }
42413 return resultobj;
42414 fail:
42415 return NULL;
42416 }
42417
42418
42419 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42420 PyObject *resultobj = 0;
42421 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42422 int arg2 ;
42423 bool result;
42424 void *argp1 = 0 ;
42425 int res1 = 0 ;
42426 int val2 ;
42427 int ecode2 = 0 ;
42428 PyObject * obj0 = 0 ;
42429 PyObject * obj1 = 0 ;
42430 char * kwnames[] = {
42431 (char *) "self",(char *) "id", NULL
42432 };
42433
42434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42436 if (!SWIG_IsOK(res1)) {
42437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42438 }
42439 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42440 ecode2 = SWIG_AsVal_int(obj1, &val2);
42441 if (!SWIG_IsOK(ecode2)) {
42442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42443 }
42444 arg2 = static_cast< int >(val2);
42445 {
42446 PyThreadState* __tstate = wxPyBeginAllowThreads();
42447 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42448 wxPyEndAllowThreads(__tstate);
42449 if (PyErr_Occurred()) SWIG_fail;
42450 }
42451 {
42452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42453 }
42454 return resultobj;
42455 fail:
42456 return NULL;
42457 }
42458
42459
42460 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42461 PyObject *resultobj = 0;
42462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42463 int arg2 ;
42464 wxString *arg3 = 0 ;
42465 void *argp1 = 0 ;
42466 int res1 = 0 ;
42467 int val2 ;
42468 int ecode2 = 0 ;
42469 bool temp3 = false ;
42470 PyObject * obj0 = 0 ;
42471 PyObject * obj1 = 0 ;
42472 PyObject * obj2 = 0 ;
42473 char * kwnames[] = {
42474 (char *) "self",(char *) "id",(char *) "label", NULL
42475 };
42476
42477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42479 if (!SWIG_IsOK(res1)) {
42480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42481 }
42482 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42483 ecode2 = SWIG_AsVal_int(obj1, &val2);
42484 if (!SWIG_IsOK(ecode2)) {
42485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42486 }
42487 arg2 = static_cast< int >(val2);
42488 {
42489 arg3 = wxString_in_helper(obj2);
42490 if (arg3 == NULL) SWIG_fail;
42491 temp3 = true;
42492 }
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42496 wxPyEndAllowThreads(__tstate);
42497 if (PyErr_Occurred()) SWIG_fail;
42498 }
42499 resultobj = SWIG_Py_Void();
42500 {
42501 if (temp3)
42502 delete arg3;
42503 }
42504 return resultobj;
42505 fail:
42506 {
42507 if (temp3)
42508 delete arg3;
42509 }
42510 return NULL;
42511 }
42512
42513
42514 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42515 PyObject *resultobj = 0;
42516 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42517 int arg2 ;
42518 wxString result;
42519 void *argp1 = 0 ;
42520 int res1 = 0 ;
42521 int val2 ;
42522 int ecode2 = 0 ;
42523 PyObject * obj0 = 0 ;
42524 PyObject * obj1 = 0 ;
42525 char * kwnames[] = {
42526 (char *) "self",(char *) "id", NULL
42527 };
42528
42529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42531 if (!SWIG_IsOK(res1)) {
42532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42533 }
42534 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42535 ecode2 = SWIG_AsVal_int(obj1, &val2);
42536 if (!SWIG_IsOK(ecode2)) {
42537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42538 }
42539 arg2 = static_cast< int >(val2);
42540 {
42541 PyThreadState* __tstate = wxPyBeginAllowThreads();
42542 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42543 wxPyEndAllowThreads(__tstate);
42544 if (PyErr_Occurred()) SWIG_fail;
42545 }
42546 {
42547 #if wxUSE_UNICODE
42548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42549 #else
42550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42551 #endif
42552 }
42553 return resultobj;
42554 fail:
42555 return NULL;
42556 }
42557
42558
42559 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42560 PyObject *resultobj = 0;
42561 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42562 int arg2 ;
42563 wxString *arg3 = 0 ;
42564 void *argp1 = 0 ;
42565 int res1 = 0 ;
42566 int val2 ;
42567 int ecode2 = 0 ;
42568 bool temp3 = false ;
42569 PyObject * obj0 = 0 ;
42570 PyObject * obj1 = 0 ;
42571 PyObject * obj2 = 0 ;
42572 char * kwnames[] = {
42573 (char *) "self",(char *) "id",(char *) "helpString", NULL
42574 };
42575
42576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42578 if (!SWIG_IsOK(res1)) {
42579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42580 }
42581 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42582 ecode2 = SWIG_AsVal_int(obj1, &val2);
42583 if (!SWIG_IsOK(ecode2)) {
42584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42585 }
42586 arg2 = static_cast< int >(val2);
42587 {
42588 arg3 = wxString_in_helper(obj2);
42589 if (arg3 == NULL) SWIG_fail;
42590 temp3 = true;
42591 }
42592 {
42593 PyThreadState* __tstate = wxPyBeginAllowThreads();
42594 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42595 wxPyEndAllowThreads(__tstate);
42596 if (PyErr_Occurred()) SWIG_fail;
42597 }
42598 resultobj = SWIG_Py_Void();
42599 {
42600 if (temp3)
42601 delete arg3;
42602 }
42603 return resultobj;
42604 fail:
42605 {
42606 if (temp3)
42607 delete arg3;
42608 }
42609 return NULL;
42610 }
42611
42612
42613 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42614 PyObject *resultobj = 0;
42615 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42616 int arg2 ;
42617 wxString result;
42618 void *argp1 = 0 ;
42619 int res1 = 0 ;
42620 int val2 ;
42621 int ecode2 = 0 ;
42622 PyObject * obj0 = 0 ;
42623 PyObject * obj1 = 0 ;
42624 char * kwnames[] = {
42625 (char *) "self",(char *) "id", NULL
42626 };
42627
42628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42630 if (!SWIG_IsOK(res1)) {
42631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42632 }
42633 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42634 ecode2 = SWIG_AsVal_int(obj1, &val2);
42635 if (!SWIG_IsOK(ecode2)) {
42636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42637 }
42638 arg2 = static_cast< int >(val2);
42639 {
42640 PyThreadState* __tstate = wxPyBeginAllowThreads();
42641 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42642 wxPyEndAllowThreads(__tstate);
42643 if (PyErr_Occurred()) SWIG_fail;
42644 }
42645 {
42646 #if wxUSE_UNICODE
42647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42648 #else
42649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42650 #endif
42651 }
42652 return resultobj;
42653 fail:
42654 return NULL;
42655 }
42656
42657
42658 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42659 PyObject *resultobj = 0;
42660 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42661 wxFrame *result = 0 ;
42662 void *argp1 = 0 ;
42663 int res1 = 0 ;
42664 PyObject *swig_obj[1] ;
42665
42666 if (!args) SWIG_fail;
42667 swig_obj[0] = args;
42668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42669 if (!SWIG_IsOK(res1)) {
42670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42671 }
42672 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42673 {
42674 PyThreadState* __tstate = wxPyBeginAllowThreads();
42675 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42676 wxPyEndAllowThreads(__tstate);
42677 if (PyErr_Occurred()) SWIG_fail;
42678 }
42679 {
42680 resultobj = wxPyMake_wxObject(result, (bool)0);
42681 }
42682 return resultobj;
42683 fail:
42684 return NULL;
42685 }
42686
42687
42688 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42689 PyObject *resultobj = 0;
42690 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42691 bool result;
42692 void *argp1 = 0 ;
42693 int res1 = 0 ;
42694 PyObject *swig_obj[1] ;
42695
42696 if (!args) SWIG_fail;
42697 swig_obj[0] = args;
42698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42699 if (!SWIG_IsOK(res1)) {
42700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42701 }
42702 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42703 {
42704 PyThreadState* __tstate = wxPyBeginAllowThreads();
42705 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42706 wxPyEndAllowThreads(__tstate);
42707 if (PyErr_Occurred()) SWIG_fail;
42708 }
42709 {
42710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42711 }
42712 return resultobj;
42713 fail:
42714 return NULL;
42715 }
42716
42717
42718 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42719 PyObject *resultobj = 0;
42720 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42721 wxFrame *arg2 = (wxFrame *) 0 ;
42722 void *argp1 = 0 ;
42723 int res1 = 0 ;
42724 void *argp2 = 0 ;
42725 int res2 = 0 ;
42726 PyObject * obj0 = 0 ;
42727 PyObject * obj1 = 0 ;
42728 char * kwnames[] = {
42729 (char *) "self",(char *) "frame", NULL
42730 };
42731
42732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42734 if (!SWIG_IsOK(res1)) {
42735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42736 }
42737 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42739 if (!SWIG_IsOK(res2)) {
42740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42741 }
42742 arg2 = reinterpret_cast< wxFrame * >(argp2);
42743 {
42744 PyThreadState* __tstate = wxPyBeginAllowThreads();
42745 (arg1)->Attach(arg2);
42746 wxPyEndAllowThreads(__tstate);
42747 if (PyErr_Occurred()) SWIG_fail;
42748 }
42749 resultobj = SWIG_Py_Void();
42750 return resultobj;
42751 fail:
42752 return NULL;
42753 }
42754
42755
42756 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42757 PyObject *resultobj = 0;
42758 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42759 void *argp1 = 0 ;
42760 int res1 = 0 ;
42761 PyObject *swig_obj[1] ;
42762
42763 if (!args) SWIG_fail;
42764 swig_obj[0] = args;
42765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42766 if (!SWIG_IsOK(res1)) {
42767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42768 }
42769 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42770 {
42771 PyThreadState* __tstate = wxPyBeginAllowThreads();
42772 (arg1)->Detach();
42773 wxPyEndAllowThreads(__tstate);
42774 if (PyErr_Occurred()) SWIG_fail;
42775 }
42776 resultobj = SWIG_Py_Void();
42777 return resultobj;
42778 fail:
42779 return NULL;
42780 }
42781
42782
42783 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42784 PyObject *resultobj = 0;
42785 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42786 void *argp1 = 0 ;
42787 int res1 = 0 ;
42788 PyObject *swig_obj[1] ;
42789
42790 if (!args) SWIG_fail;
42791 swig_obj[0] = args;
42792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42793 if (!SWIG_IsOK(res1)) {
42794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42795 }
42796 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42797 {
42798 PyThreadState* __tstate = wxPyBeginAllowThreads();
42799 (arg1)->UpdateMenus();
42800 wxPyEndAllowThreads(__tstate);
42801 if (PyErr_Occurred()) SWIG_fail;
42802 }
42803 resultobj = SWIG_Py_Void();
42804 return resultobj;
42805 fail:
42806 return NULL;
42807 }
42808
42809
42810 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42811 PyObject *resultobj = 0;
42812 bool arg1 ;
42813 bool val1 ;
42814 int ecode1 = 0 ;
42815 PyObject * obj0 = 0 ;
42816 char * kwnames[] = {
42817 (char *) "enable", NULL
42818 };
42819
42820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42821 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42822 if (!SWIG_IsOK(ecode1)) {
42823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42824 }
42825 arg1 = static_cast< bool >(val1);
42826 {
42827 PyThreadState* __tstate = wxPyBeginAllowThreads();
42828 wxMenuBar_SetAutoWindowMenu(arg1);
42829 wxPyEndAllowThreads(__tstate);
42830 if (PyErr_Occurred()) SWIG_fail;
42831 }
42832 resultobj = SWIG_Py_Void();
42833 return resultobj;
42834 fail:
42835 return NULL;
42836 }
42837
42838
42839 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42840 PyObject *resultobj = 0;
42841 bool result;
42842
42843 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42844 {
42845 PyThreadState* __tstate = wxPyBeginAllowThreads();
42846 result = (bool)wxMenuBar_GetAutoWindowMenu();
42847 wxPyEndAllowThreads(__tstate);
42848 if (PyErr_Occurred()) SWIG_fail;
42849 }
42850 {
42851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42852 }
42853 return resultobj;
42854 fail:
42855 return NULL;
42856 }
42857
42858
42859 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42860 PyObject *obj;
42861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42862 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42863 return SWIG_Py_Void();
42864 }
42865
42866 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42867 return SWIG_Python_InitShadowInstance(args);
42868 }
42869
42870 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42871 PyObject *resultobj = 0;
42872 wxMenu *arg1 = (wxMenu *) NULL ;
42873 int arg2 = (int) wxID_ANY ;
42874 wxString const &arg3_defvalue = wxPyEmptyString ;
42875 wxString *arg3 = (wxString *) &arg3_defvalue ;
42876 wxString const &arg4_defvalue = wxPyEmptyString ;
42877 wxString *arg4 = (wxString *) &arg4_defvalue ;
42878 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42879 wxMenu *arg6 = (wxMenu *) NULL ;
42880 wxMenuItem *result = 0 ;
42881 void *argp1 = 0 ;
42882 int res1 = 0 ;
42883 int val2 ;
42884 int ecode2 = 0 ;
42885 bool temp3 = false ;
42886 bool temp4 = false ;
42887 int val5 ;
42888 int ecode5 = 0 ;
42889 void *argp6 = 0 ;
42890 int res6 = 0 ;
42891 PyObject * obj0 = 0 ;
42892 PyObject * obj1 = 0 ;
42893 PyObject * obj2 = 0 ;
42894 PyObject * obj3 = 0 ;
42895 PyObject * obj4 = 0 ;
42896 PyObject * obj5 = 0 ;
42897 char * kwnames[] = {
42898 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42899 };
42900
42901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42902 if (obj0) {
42903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42904 if (!SWIG_IsOK(res1)) {
42905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42906 }
42907 arg1 = reinterpret_cast< wxMenu * >(argp1);
42908 }
42909 if (obj1) {
42910 ecode2 = SWIG_AsVal_int(obj1, &val2);
42911 if (!SWIG_IsOK(ecode2)) {
42912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42913 }
42914 arg2 = static_cast< int >(val2);
42915 }
42916 if (obj2) {
42917 {
42918 arg3 = wxString_in_helper(obj2);
42919 if (arg3 == NULL) SWIG_fail;
42920 temp3 = true;
42921 }
42922 }
42923 if (obj3) {
42924 {
42925 arg4 = wxString_in_helper(obj3);
42926 if (arg4 == NULL) SWIG_fail;
42927 temp4 = true;
42928 }
42929 }
42930 if (obj4) {
42931 ecode5 = SWIG_AsVal_int(obj4, &val5);
42932 if (!SWIG_IsOK(ecode5)) {
42933 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42934 }
42935 arg5 = static_cast< wxItemKind >(val5);
42936 }
42937 if (obj5) {
42938 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42939 if (!SWIG_IsOK(res6)) {
42940 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42941 }
42942 arg6 = reinterpret_cast< wxMenu * >(argp6);
42943 }
42944 {
42945 PyThreadState* __tstate = wxPyBeginAllowThreads();
42946 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42947 wxPyEndAllowThreads(__tstate);
42948 if (PyErr_Occurred()) SWIG_fail;
42949 }
42950 {
42951 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42952 }
42953 {
42954 if (temp3)
42955 delete arg3;
42956 }
42957 {
42958 if (temp4)
42959 delete arg4;
42960 }
42961 return resultobj;
42962 fail:
42963 {
42964 if (temp3)
42965 delete arg3;
42966 }
42967 {
42968 if (temp4)
42969 delete arg4;
42970 }
42971 return NULL;
42972 }
42973
42974
42975 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42976 PyObject *resultobj = 0;
42977 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42978 void *argp1 = 0 ;
42979 int res1 = 0 ;
42980 PyObject *swig_obj[1] ;
42981
42982 if (!args) SWIG_fail;
42983 swig_obj[0] = args;
42984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42985 if (!SWIG_IsOK(res1)) {
42986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42987 }
42988 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42989 {
42990 PyThreadState* __tstate = wxPyBeginAllowThreads();
42991 delete arg1;
42992
42993 wxPyEndAllowThreads(__tstate);
42994 if (PyErr_Occurred()) SWIG_fail;
42995 }
42996 resultobj = SWIG_Py_Void();
42997 return resultobj;
42998 fail:
42999 return NULL;
43000 }
43001
43002
43003 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43004 PyObject *resultobj = 0;
43005 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43006 wxMenu *result = 0 ;
43007 void *argp1 = 0 ;
43008 int res1 = 0 ;
43009 PyObject *swig_obj[1] ;
43010
43011 if (!args) SWIG_fail;
43012 swig_obj[0] = args;
43013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43014 if (!SWIG_IsOK(res1)) {
43015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43016 }
43017 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43018 {
43019 PyThreadState* __tstate = wxPyBeginAllowThreads();
43020 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43021 wxPyEndAllowThreads(__tstate);
43022 if (PyErr_Occurred()) SWIG_fail;
43023 }
43024 {
43025 resultobj = wxPyMake_wxObject(result, 0);
43026 }
43027 return resultobj;
43028 fail:
43029 return NULL;
43030 }
43031
43032
43033 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43034 PyObject *resultobj = 0;
43035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43036 wxMenu *arg2 = (wxMenu *) 0 ;
43037 void *argp1 = 0 ;
43038 int res1 = 0 ;
43039 void *argp2 = 0 ;
43040 int res2 = 0 ;
43041 PyObject * obj0 = 0 ;
43042 PyObject * obj1 = 0 ;
43043 char * kwnames[] = {
43044 (char *) "self",(char *) "menu", NULL
43045 };
43046
43047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43049 if (!SWIG_IsOK(res1)) {
43050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43051 }
43052 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43054 if (!SWIG_IsOK(res2)) {
43055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43056 }
43057 arg2 = reinterpret_cast< wxMenu * >(argp2);
43058 {
43059 PyThreadState* __tstate = wxPyBeginAllowThreads();
43060 (arg1)->SetMenu(arg2);
43061 wxPyEndAllowThreads(__tstate);
43062 if (PyErr_Occurred()) SWIG_fail;
43063 }
43064 resultobj = SWIG_Py_Void();
43065 return resultobj;
43066 fail:
43067 return NULL;
43068 }
43069
43070
43071 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43072 PyObject *resultobj = 0;
43073 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43074 int arg2 ;
43075 void *argp1 = 0 ;
43076 int res1 = 0 ;
43077 int val2 ;
43078 int ecode2 = 0 ;
43079 PyObject * obj0 = 0 ;
43080 PyObject * obj1 = 0 ;
43081 char * kwnames[] = {
43082 (char *) "self",(char *) "id", NULL
43083 };
43084
43085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43087 if (!SWIG_IsOK(res1)) {
43088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43089 }
43090 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43091 ecode2 = SWIG_AsVal_int(obj1, &val2);
43092 if (!SWIG_IsOK(ecode2)) {
43093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43094 }
43095 arg2 = static_cast< int >(val2);
43096 {
43097 PyThreadState* __tstate = wxPyBeginAllowThreads();
43098 (arg1)->SetId(arg2);
43099 wxPyEndAllowThreads(__tstate);
43100 if (PyErr_Occurred()) SWIG_fail;
43101 }
43102 resultobj = SWIG_Py_Void();
43103 return resultobj;
43104 fail:
43105 return NULL;
43106 }
43107
43108
43109 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43110 PyObject *resultobj = 0;
43111 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43112 int result;
43113 void *argp1 = 0 ;
43114 int res1 = 0 ;
43115 PyObject *swig_obj[1] ;
43116
43117 if (!args) SWIG_fail;
43118 swig_obj[0] = args;
43119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43120 if (!SWIG_IsOK(res1)) {
43121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43122 }
43123 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43124 {
43125 PyThreadState* __tstate = wxPyBeginAllowThreads();
43126 result = (int)((wxMenuItem const *)arg1)->GetId();
43127 wxPyEndAllowThreads(__tstate);
43128 if (PyErr_Occurred()) SWIG_fail;
43129 }
43130 resultobj = SWIG_From_int(static_cast< int >(result));
43131 return resultobj;
43132 fail:
43133 return NULL;
43134 }
43135
43136
43137 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43138 PyObject *resultobj = 0;
43139 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43140 bool result;
43141 void *argp1 = 0 ;
43142 int res1 = 0 ;
43143 PyObject *swig_obj[1] ;
43144
43145 if (!args) SWIG_fail;
43146 swig_obj[0] = args;
43147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43148 if (!SWIG_IsOK(res1)) {
43149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43150 }
43151 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43152 {
43153 PyThreadState* __tstate = wxPyBeginAllowThreads();
43154 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43155 wxPyEndAllowThreads(__tstate);
43156 if (PyErr_Occurred()) SWIG_fail;
43157 }
43158 {
43159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43160 }
43161 return resultobj;
43162 fail:
43163 return NULL;
43164 }
43165
43166
43167 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43168 PyObject *resultobj = 0;
43169 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43170 wxString *arg2 = 0 ;
43171 void *argp1 = 0 ;
43172 int res1 = 0 ;
43173 bool temp2 = false ;
43174 PyObject * obj0 = 0 ;
43175 PyObject * obj1 = 0 ;
43176 char * kwnames[] = {
43177 (char *) "self",(char *) "str", NULL
43178 };
43179
43180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43182 if (!SWIG_IsOK(res1)) {
43183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43184 }
43185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43186 {
43187 arg2 = wxString_in_helper(obj1);
43188 if (arg2 == NULL) SWIG_fail;
43189 temp2 = true;
43190 }
43191 {
43192 PyThreadState* __tstate = wxPyBeginAllowThreads();
43193 (arg1)->SetText((wxString const &)*arg2);
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 resultobj = SWIG_Py_Void();
43198 {
43199 if (temp2)
43200 delete arg2;
43201 }
43202 return resultobj;
43203 fail:
43204 {
43205 if (temp2)
43206 delete arg2;
43207 }
43208 return NULL;
43209 }
43210
43211
43212 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43213 PyObject *resultobj = 0;
43214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43215 wxString result;
43216 void *argp1 = 0 ;
43217 int res1 = 0 ;
43218 PyObject *swig_obj[1] ;
43219
43220 if (!args) SWIG_fail;
43221 swig_obj[0] = args;
43222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43223 if (!SWIG_IsOK(res1)) {
43224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43225 }
43226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43227 {
43228 PyThreadState* __tstate = wxPyBeginAllowThreads();
43229 result = ((wxMenuItem const *)arg1)->GetLabel();
43230 wxPyEndAllowThreads(__tstate);
43231 if (PyErr_Occurred()) SWIG_fail;
43232 }
43233 {
43234 #if wxUSE_UNICODE
43235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43236 #else
43237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43238 #endif
43239 }
43240 return resultobj;
43241 fail:
43242 return NULL;
43243 }
43244
43245
43246 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43247 PyObject *resultobj = 0;
43248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43249 wxString *result = 0 ;
43250 void *argp1 = 0 ;
43251 int res1 = 0 ;
43252 PyObject *swig_obj[1] ;
43253
43254 if (!args) SWIG_fail;
43255 swig_obj[0] = args;
43256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43257 if (!SWIG_IsOK(res1)) {
43258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43259 }
43260 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43261 {
43262 PyThreadState* __tstate = wxPyBeginAllowThreads();
43263 {
43264 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43265 result = (wxString *) &_result_ref;
43266 }
43267 wxPyEndAllowThreads(__tstate);
43268 if (PyErr_Occurred()) SWIG_fail;
43269 }
43270 {
43271 #if wxUSE_UNICODE
43272 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43273 #else
43274 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43275 #endif
43276 }
43277 return resultobj;
43278 fail:
43279 return NULL;
43280 }
43281
43282
43283 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43284 PyObject *resultobj = 0;
43285 wxString *arg1 = 0 ;
43286 wxString result;
43287 bool temp1 = false ;
43288 PyObject * obj0 = 0 ;
43289 char * kwnames[] = {
43290 (char *) "text", NULL
43291 };
43292
43293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43294 {
43295 arg1 = wxString_in_helper(obj0);
43296 if (arg1 == NULL) SWIG_fail;
43297 temp1 = true;
43298 }
43299 {
43300 PyThreadState* __tstate = wxPyBeginAllowThreads();
43301 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43302 wxPyEndAllowThreads(__tstate);
43303 if (PyErr_Occurred()) SWIG_fail;
43304 }
43305 {
43306 #if wxUSE_UNICODE
43307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43308 #else
43309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43310 #endif
43311 }
43312 {
43313 if (temp1)
43314 delete arg1;
43315 }
43316 return resultobj;
43317 fail:
43318 {
43319 if (temp1)
43320 delete arg1;
43321 }
43322 return NULL;
43323 }
43324
43325
43326 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43327 PyObject *resultobj = 0;
43328 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43329 wxItemKind result;
43330 void *argp1 = 0 ;
43331 int res1 = 0 ;
43332 PyObject *swig_obj[1] ;
43333
43334 if (!args) SWIG_fail;
43335 swig_obj[0] = args;
43336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43337 if (!SWIG_IsOK(res1)) {
43338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43339 }
43340 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43341 {
43342 PyThreadState* __tstate = wxPyBeginAllowThreads();
43343 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43344 wxPyEndAllowThreads(__tstate);
43345 if (PyErr_Occurred()) SWIG_fail;
43346 }
43347 resultobj = SWIG_From_int(static_cast< int >(result));
43348 return resultobj;
43349 fail:
43350 return NULL;
43351 }
43352
43353
43354 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43355 PyObject *resultobj = 0;
43356 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43357 wxItemKind arg2 ;
43358 void *argp1 = 0 ;
43359 int res1 = 0 ;
43360 int val2 ;
43361 int ecode2 = 0 ;
43362 PyObject * obj0 = 0 ;
43363 PyObject * obj1 = 0 ;
43364 char * kwnames[] = {
43365 (char *) "self",(char *) "kind", NULL
43366 };
43367
43368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43370 if (!SWIG_IsOK(res1)) {
43371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43372 }
43373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43374 ecode2 = SWIG_AsVal_int(obj1, &val2);
43375 if (!SWIG_IsOK(ecode2)) {
43376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43377 }
43378 arg2 = static_cast< wxItemKind >(val2);
43379 {
43380 PyThreadState* __tstate = wxPyBeginAllowThreads();
43381 (arg1)->SetKind(arg2);
43382 wxPyEndAllowThreads(__tstate);
43383 if (PyErr_Occurred()) SWIG_fail;
43384 }
43385 resultobj = SWIG_Py_Void();
43386 return resultobj;
43387 fail:
43388 return NULL;
43389 }
43390
43391
43392 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43393 PyObject *resultobj = 0;
43394 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43395 bool arg2 ;
43396 void *argp1 = 0 ;
43397 int res1 = 0 ;
43398 bool val2 ;
43399 int ecode2 = 0 ;
43400 PyObject * obj0 = 0 ;
43401 PyObject * obj1 = 0 ;
43402 char * kwnames[] = {
43403 (char *) "self",(char *) "checkable", NULL
43404 };
43405
43406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43408 if (!SWIG_IsOK(res1)) {
43409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43410 }
43411 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43412 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43413 if (!SWIG_IsOK(ecode2)) {
43414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43415 }
43416 arg2 = static_cast< bool >(val2);
43417 {
43418 PyThreadState* __tstate = wxPyBeginAllowThreads();
43419 (arg1)->SetCheckable(arg2);
43420 wxPyEndAllowThreads(__tstate);
43421 if (PyErr_Occurred()) SWIG_fail;
43422 }
43423 resultobj = SWIG_Py_Void();
43424 return resultobj;
43425 fail:
43426 return NULL;
43427 }
43428
43429
43430 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43431 PyObject *resultobj = 0;
43432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43433 bool result;
43434 void *argp1 = 0 ;
43435 int res1 = 0 ;
43436 PyObject *swig_obj[1] ;
43437
43438 if (!args) SWIG_fail;
43439 swig_obj[0] = args;
43440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43441 if (!SWIG_IsOK(res1)) {
43442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43443 }
43444 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43445 {
43446 PyThreadState* __tstate = wxPyBeginAllowThreads();
43447 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43448 wxPyEndAllowThreads(__tstate);
43449 if (PyErr_Occurred()) SWIG_fail;
43450 }
43451 {
43452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43453 }
43454 return resultobj;
43455 fail:
43456 return NULL;
43457 }
43458
43459
43460 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43461 PyObject *resultobj = 0;
43462 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43463 bool result;
43464 void *argp1 = 0 ;
43465 int res1 = 0 ;
43466 PyObject *swig_obj[1] ;
43467
43468 if (!args) SWIG_fail;
43469 swig_obj[0] = args;
43470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43471 if (!SWIG_IsOK(res1)) {
43472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43473 }
43474 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43475 {
43476 PyThreadState* __tstate = wxPyBeginAllowThreads();
43477 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43478 wxPyEndAllowThreads(__tstate);
43479 if (PyErr_Occurred()) SWIG_fail;
43480 }
43481 {
43482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43483 }
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43491 PyObject *resultobj = 0;
43492 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43493 wxMenu *arg2 = (wxMenu *) 0 ;
43494 void *argp1 = 0 ;
43495 int res1 = 0 ;
43496 void *argp2 = 0 ;
43497 int res2 = 0 ;
43498 PyObject * obj0 = 0 ;
43499 PyObject * obj1 = 0 ;
43500 char * kwnames[] = {
43501 (char *) "self",(char *) "menu", NULL
43502 };
43503
43504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43506 if (!SWIG_IsOK(res1)) {
43507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43508 }
43509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43510 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43511 if (!SWIG_IsOK(res2)) {
43512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43513 }
43514 arg2 = reinterpret_cast< wxMenu * >(argp2);
43515 {
43516 PyThreadState* __tstate = wxPyBeginAllowThreads();
43517 (arg1)->SetSubMenu(arg2);
43518 wxPyEndAllowThreads(__tstate);
43519 if (PyErr_Occurred()) SWIG_fail;
43520 }
43521 resultobj = SWIG_Py_Void();
43522 return resultobj;
43523 fail:
43524 return NULL;
43525 }
43526
43527
43528 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43529 PyObject *resultobj = 0;
43530 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43531 wxMenu *result = 0 ;
43532 void *argp1 = 0 ;
43533 int res1 = 0 ;
43534 PyObject *swig_obj[1] ;
43535
43536 if (!args) SWIG_fail;
43537 swig_obj[0] = args;
43538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43539 if (!SWIG_IsOK(res1)) {
43540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43541 }
43542 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43543 {
43544 PyThreadState* __tstate = wxPyBeginAllowThreads();
43545 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43546 wxPyEndAllowThreads(__tstate);
43547 if (PyErr_Occurred()) SWIG_fail;
43548 }
43549 {
43550 resultobj = wxPyMake_wxObject(result, 0);
43551 }
43552 return resultobj;
43553 fail:
43554 return NULL;
43555 }
43556
43557
43558 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43559 PyObject *resultobj = 0;
43560 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43561 bool arg2 = (bool) true ;
43562 void *argp1 = 0 ;
43563 int res1 = 0 ;
43564 bool val2 ;
43565 int ecode2 = 0 ;
43566 PyObject * obj0 = 0 ;
43567 PyObject * obj1 = 0 ;
43568 char * kwnames[] = {
43569 (char *) "self",(char *) "enable", NULL
43570 };
43571
43572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43574 if (!SWIG_IsOK(res1)) {
43575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43576 }
43577 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43578 if (obj1) {
43579 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43580 if (!SWIG_IsOK(ecode2)) {
43581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43582 }
43583 arg2 = static_cast< bool >(val2);
43584 }
43585 {
43586 PyThreadState* __tstate = wxPyBeginAllowThreads();
43587 (arg1)->Enable(arg2);
43588 wxPyEndAllowThreads(__tstate);
43589 if (PyErr_Occurred()) SWIG_fail;
43590 }
43591 resultobj = SWIG_Py_Void();
43592 return resultobj;
43593 fail:
43594 return NULL;
43595 }
43596
43597
43598 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43599 PyObject *resultobj = 0;
43600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43601 bool result;
43602 void *argp1 = 0 ;
43603 int res1 = 0 ;
43604 PyObject *swig_obj[1] ;
43605
43606 if (!args) SWIG_fail;
43607 swig_obj[0] = args;
43608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43609 if (!SWIG_IsOK(res1)) {
43610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43611 }
43612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43613 {
43614 PyThreadState* __tstate = wxPyBeginAllowThreads();
43615 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43616 wxPyEndAllowThreads(__tstate);
43617 if (PyErr_Occurred()) SWIG_fail;
43618 }
43619 {
43620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43621 }
43622 return resultobj;
43623 fail:
43624 return NULL;
43625 }
43626
43627
43628 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43629 PyObject *resultobj = 0;
43630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43631 bool arg2 = (bool) true ;
43632 void *argp1 = 0 ;
43633 int res1 = 0 ;
43634 bool val2 ;
43635 int ecode2 = 0 ;
43636 PyObject * obj0 = 0 ;
43637 PyObject * obj1 = 0 ;
43638 char * kwnames[] = {
43639 (char *) "self",(char *) "check", NULL
43640 };
43641
43642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43644 if (!SWIG_IsOK(res1)) {
43645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43646 }
43647 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43648 if (obj1) {
43649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43650 if (!SWIG_IsOK(ecode2)) {
43651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43652 }
43653 arg2 = static_cast< bool >(val2);
43654 }
43655 {
43656 PyThreadState* __tstate = wxPyBeginAllowThreads();
43657 (arg1)->Check(arg2);
43658 wxPyEndAllowThreads(__tstate);
43659 if (PyErr_Occurred()) SWIG_fail;
43660 }
43661 resultobj = SWIG_Py_Void();
43662 return resultobj;
43663 fail:
43664 return NULL;
43665 }
43666
43667
43668 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43669 PyObject *resultobj = 0;
43670 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43671 bool result;
43672 void *argp1 = 0 ;
43673 int res1 = 0 ;
43674 PyObject *swig_obj[1] ;
43675
43676 if (!args) SWIG_fail;
43677 swig_obj[0] = args;
43678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43679 if (!SWIG_IsOK(res1)) {
43680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43681 }
43682 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43683 {
43684 PyThreadState* __tstate = wxPyBeginAllowThreads();
43685 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43686 wxPyEndAllowThreads(__tstate);
43687 if (PyErr_Occurred()) SWIG_fail;
43688 }
43689 {
43690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43691 }
43692 return resultobj;
43693 fail:
43694 return NULL;
43695 }
43696
43697
43698 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43699 PyObject *resultobj = 0;
43700 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43701 void *argp1 = 0 ;
43702 int res1 = 0 ;
43703 PyObject *swig_obj[1] ;
43704
43705 if (!args) SWIG_fail;
43706 swig_obj[0] = args;
43707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43708 if (!SWIG_IsOK(res1)) {
43709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43710 }
43711 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43712 {
43713 PyThreadState* __tstate = wxPyBeginAllowThreads();
43714 (arg1)->Toggle();
43715 wxPyEndAllowThreads(__tstate);
43716 if (PyErr_Occurred()) SWIG_fail;
43717 }
43718 resultobj = SWIG_Py_Void();
43719 return resultobj;
43720 fail:
43721 return NULL;
43722 }
43723
43724
43725 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43726 PyObject *resultobj = 0;
43727 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43728 wxString *arg2 = 0 ;
43729 void *argp1 = 0 ;
43730 int res1 = 0 ;
43731 bool temp2 = false ;
43732 PyObject * obj0 = 0 ;
43733 PyObject * obj1 = 0 ;
43734 char * kwnames[] = {
43735 (char *) "self",(char *) "str", NULL
43736 };
43737
43738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43740 if (!SWIG_IsOK(res1)) {
43741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43742 }
43743 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43744 {
43745 arg2 = wxString_in_helper(obj1);
43746 if (arg2 == NULL) SWIG_fail;
43747 temp2 = true;
43748 }
43749 {
43750 PyThreadState* __tstate = wxPyBeginAllowThreads();
43751 (arg1)->SetHelp((wxString const &)*arg2);
43752 wxPyEndAllowThreads(__tstate);
43753 if (PyErr_Occurred()) SWIG_fail;
43754 }
43755 resultobj = SWIG_Py_Void();
43756 {
43757 if (temp2)
43758 delete arg2;
43759 }
43760 return resultobj;
43761 fail:
43762 {
43763 if (temp2)
43764 delete arg2;
43765 }
43766 return NULL;
43767 }
43768
43769
43770 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43771 PyObject *resultobj = 0;
43772 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43773 wxString *result = 0 ;
43774 void *argp1 = 0 ;
43775 int res1 = 0 ;
43776 PyObject *swig_obj[1] ;
43777
43778 if (!args) SWIG_fail;
43779 swig_obj[0] = args;
43780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43781 if (!SWIG_IsOK(res1)) {
43782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43783 }
43784 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43785 {
43786 PyThreadState* __tstate = wxPyBeginAllowThreads();
43787 {
43788 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43789 result = (wxString *) &_result_ref;
43790 }
43791 wxPyEndAllowThreads(__tstate);
43792 if (PyErr_Occurred()) SWIG_fail;
43793 }
43794 {
43795 #if wxUSE_UNICODE
43796 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43797 #else
43798 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43799 #endif
43800 }
43801 return resultobj;
43802 fail:
43803 return NULL;
43804 }
43805
43806
43807 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43808 PyObject *resultobj = 0;
43809 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43810 wxAcceleratorEntry *result = 0 ;
43811 void *argp1 = 0 ;
43812 int res1 = 0 ;
43813 PyObject *swig_obj[1] ;
43814
43815 if (!args) SWIG_fail;
43816 swig_obj[0] = args;
43817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43818 if (!SWIG_IsOK(res1)) {
43819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43820 }
43821 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43822 {
43823 PyThreadState* __tstate = wxPyBeginAllowThreads();
43824 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43825 wxPyEndAllowThreads(__tstate);
43826 if (PyErr_Occurred()) SWIG_fail;
43827 }
43828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43829 return resultobj;
43830 fail:
43831 return NULL;
43832 }
43833
43834
43835 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43836 PyObject *resultobj = 0;
43837 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43838 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43839 void *argp1 = 0 ;
43840 int res1 = 0 ;
43841 void *argp2 = 0 ;
43842 int res2 = 0 ;
43843 PyObject * obj0 = 0 ;
43844 PyObject * obj1 = 0 ;
43845 char * kwnames[] = {
43846 (char *) "self",(char *) "accel", NULL
43847 };
43848
43849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43851 if (!SWIG_IsOK(res1)) {
43852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43853 }
43854 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43856 if (!SWIG_IsOK(res2)) {
43857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43858 }
43859 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43860 {
43861 PyThreadState* __tstate = wxPyBeginAllowThreads();
43862 (arg1)->SetAccel(arg2);
43863 wxPyEndAllowThreads(__tstate);
43864 if (PyErr_Occurred()) SWIG_fail;
43865 }
43866 resultobj = SWIG_Py_Void();
43867 return resultobj;
43868 fail:
43869 return NULL;
43870 }
43871
43872
43873 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43874 PyObject *resultobj = 0;
43875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43876 wxBitmap *arg2 = 0 ;
43877 void *argp1 = 0 ;
43878 int res1 = 0 ;
43879 void *argp2 = 0 ;
43880 int res2 = 0 ;
43881 PyObject * obj0 = 0 ;
43882 PyObject * obj1 = 0 ;
43883 char * kwnames[] = {
43884 (char *) "self",(char *) "bitmap", NULL
43885 };
43886
43887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43889 if (!SWIG_IsOK(res1)) {
43890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43891 }
43892 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43894 if (!SWIG_IsOK(res2)) {
43895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43896 }
43897 if (!argp2) {
43898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43899 }
43900 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43901 {
43902 PyThreadState* __tstate = wxPyBeginAllowThreads();
43903 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43904 wxPyEndAllowThreads(__tstate);
43905 if (PyErr_Occurred()) SWIG_fail;
43906 }
43907 resultobj = SWIG_Py_Void();
43908 return resultobj;
43909 fail:
43910 return NULL;
43911 }
43912
43913
43914 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43915 PyObject *resultobj = 0;
43916 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43917 wxBitmap *result = 0 ;
43918 void *argp1 = 0 ;
43919 int res1 = 0 ;
43920 PyObject *swig_obj[1] ;
43921
43922 if (!args) SWIG_fail;
43923 swig_obj[0] = args;
43924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43925 if (!SWIG_IsOK(res1)) {
43926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43927 }
43928 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 {
43932 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43933 result = (wxBitmap *) &_result_ref;
43934 }
43935 wxPyEndAllowThreads(__tstate);
43936 if (PyErr_Occurred()) SWIG_fail;
43937 }
43938 {
43939 wxBitmap* resultptr = new wxBitmap(*result);
43940 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43941 }
43942 return resultobj;
43943 fail:
43944 return NULL;
43945 }
43946
43947
43948 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43949 PyObject *resultobj = 0;
43950 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43951 wxFont *arg2 = 0 ;
43952 void *argp1 = 0 ;
43953 int res1 = 0 ;
43954 void *argp2 = 0 ;
43955 int res2 = 0 ;
43956 PyObject * obj0 = 0 ;
43957 PyObject * obj1 = 0 ;
43958 char * kwnames[] = {
43959 (char *) "self",(char *) "font", NULL
43960 };
43961
43962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43964 if (!SWIG_IsOK(res1)) {
43965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43966 }
43967 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43969 if (!SWIG_IsOK(res2)) {
43970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43971 }
43972 if (!argp2) {
43973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43974 }
43975 arg2 = reinterpret_cast< wxFont * >(argp2);
43976 {
43977 PyThreadState* __tstate = wxPyBeginAllowThreads();
43978 (arg1)->SetFont((wxFont const &)*arg2);
43979 wxPyEndAllowThreads(__tstate);
43980 if (PyErr_Occurred()) SWIG_fail;
43981 }
43982 resultobj = SWIG_Py_Void();
43983 return resultobj;
43984 fail:
43985 return NULL;
43986 }
43987
43988
43989 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43990 PyObject *resultobj = 0;
43991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43992 wxFont result;
43993 void *argp1 = 0 ;
43994 int res1 = 0 ;
43995 PyObject *swig_obj[1] ;
43996
43997 if (!args) SWIG_fail;
43998 swig_obj[0] = args;
43999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44000 if (!SWIG_IsOK(res1)) {
44001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44002 }
44003 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44004 {
44005 PyThreadState* __tstate = wxPyBeginAllowThreads();
44006 result = (arg1)->GetFont();
44007 wxPyEndAllowThreads(__tstate);
44008 if (PyErr_Occurred()) SWIG_fail;
44009 }
44010 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44011 return resultobj;
44012 fail:
44013 return NULL;
44014 }
44015
44016
44017 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44018 PyObject *resultobj = 0;
44019 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44020 wxColour *arg2 = 0 ;
44021 void *argp1 = 0 ;
44022 int res1 = 0 ;
44023 wxColour temp2 ;
44024 PyObject * obj0 = 0 ;
44025 PyObject * obj1 = 0 ;
44026 char * kwnames[] = {
44027 (char *) "self",(char *) "colText", NULL
44028 };
44029
44030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44032 if (!SWIG_IsOK(res1)) {
44033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44034 }
44035 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44036 {
44037 arg2 = &temp2;
44038 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44039 }
44040 {
44041 PyThreadState* __tstate = wxPyBeginAllowThreads();
44042 (arg1)->SetTextColour((wxColour const &)*arg2);
44043 wxPyEndAllowThreads(__tstate);
44044 if (PyErr_Occurred()) SWIG_fail;
44045 }
44046 resultobj = SWIG_Py_Void();
44047 return resultobj;
44048 fail:
44049 return NULL;
44050 }
44051
44052
44053 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44054 PyObject *resultobj = 0;
44055 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44056 wxColour result;
44057 void *argp1 = 0 ;
44058 int res1 = 0 ;
44059 PyObject *swig_obj[1] ;
44060
44061 if (!args) SWIG_fail;
44062 swig_obj[0] = args;
44063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44064 if (!SWIG_IsOK(res1)) {
44065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44066 }
44067 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44068 {
44069 PyThreadState* __tstate = wxPyBeginAllowThreads();
44070 result = (arg1)->GetTextColour();
44071 wxPyEndAllowThreads(__tstate);
44072 if (PyErr_Occurred()) SWIG_fail;
44073 }
44074 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44075 return resultobj;
44076 fail:
44077 return NULL;
44078 }
44079
44080
44081 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44082 PyObject *resultobj = 0;
44083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44084 wxColour *arg2 = 0 ;
44085 void *argp1 = 0 ;
44086 int res1 = 0 ;
44087 wxColour temp2 ;
44088 PyObject * obj0 = 0 ;
44089 PyObject * obj1 = 0 ;
44090 char * kwnames[] = {
44091 (char *) "self",(char *) "colBack", NULL
44092 };
44093
44094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44096 if (!SWIG_IsOK(res1)) {
44097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44098 }
44099 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44100 {
44101 arg2 = &temp2;
44102 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44103 }
44104 {
44105 PyThreadState* __tstate = wxPyBeginAllowThreads();
44106 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
44107 wxPyEndAllowThreads(__tstate);
44108 if (PyErr_Occurred()) SWIG_fail;
44109 }
44110 resultobj = SWIG_Py_Void();
44111 return resultobj;
44112 fail:
44113 return NULL;
44114 }
44115
44116
44117 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44118 PyObject *resultobj = 0;
44119 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44120 wxColour result;
44121 void *argp1 = 0 ;
44122 int res1 = 0 ;
44123 PyObject *swig_obj[1] ;
44124
44125 if (!args) SWIG_fail;
44126 swig_obj[0] = args;
44127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44128 if (!SWIG_IsOK(res1)) {
44129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44130 }
44131 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44132 {
44133 PyThreadState* __tstate = wxPyBeginAllowThreads();
44134 result = (arg1)->GetBackgroundColour();
44135 wxPyEndAllowThreads(__tstate);
44136 if (PyErr_Occurred()) SWIG_fail;
44137 }
44138 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44139 return resultobj;
44140 fail:
44141 return NULL;
44142 }
44143
44144
44145 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44146 PyObject *resultobj = 0;
44147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44148 wxBitmap *arg2 = 0 ;
44149 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44150 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44151 void *argp1 = 0 ;
44152 int res1 = 0 ;
44153 void *argp2 = 0 ;
44154 int res2 = 0 ;
44155 void *argp3 = 0 ;
44156 int res3 = 0 ;
44157 PyObject * obj0 = 0 ;
44158 PyObject * obj1 = 0 ;
44159 PyObject * obj2 = 0 ;
44160 char * kwnames[] = {
44161 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44162 };
44163
44164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44166 if (!SWIG_IsOK(res1)) {
44167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44168 }
44169 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44170 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44171 if (!SWIG_IsOK(res2)) {
44172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44173 }
44174 if (!argp2) {
44175 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44176 }
44177 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44178 if (obj2) {
44179 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44180 if (!SWIG_IsOK(res3)) {
44181 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44182 }
44183 if (!argp3) {
44184 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44185 }
44186 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44187 }
44188 {
44189 PyThreadState* __tstate = wxPyBeginAllowThreads();
44190 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44191 wxPyEndAllowThreads(__tstate);
44192 if (PyErr_Occurred()) SWIG_fail;
44193 }
44194 resultobj = SWIG_Py_Void();
44195 return resultobj;
44196 fail:
44197 return NULL;
44198 }
44199
44200
44201 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44202 PyObject *resultobj = 0;
44203 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44204 wxBitmap *arg2 = 0 ;
44205 void *argp1 = 0 ;
44206 int res1 = 0 ;
44207 void *argp2 = 0 ;
44208 int res2 = 0 ;
44209 PyObject * obj0 = 0 ;
44210 PyObject * obj1 = 0 ;
44211 char * kwnames[] = {
44212 (char *) "self",(char *) "bmpDisabled", NULL
44213 };
44214
44215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44217 if (!SWIG_IsOK(res1)) {
44218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44219 }
44220 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44221 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44222 if (!SWIG_IsOK(res2)) {
44223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44224 }
44225 if (!argp2) {
44226 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44227 }
44228 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44229 {
44230 PyThreadState* __tstate = wxPyBeginAllowThreads();
44231 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
44232 wxPyEndAllowThreads(__tstate);
44233 if (PyErr_Occurred()) SWIG_fail;
44234 }
44235 resultobj = SWIG_Py_Void();
44236 return resultobj;
44237 fail:
44238 return NULL;
44239 }
44240
44241
44242 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44243 PyObject *resultobj = 0;
44244 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44245 wxBitmap *result = 0 ;
44246 void *argp1 = 0 ;
44247 int res1 = 0 ;
44248 PyObject *swig_obj[1] ;
44249
44250 if (!args) SWIG_fail;
44251 swig_obj[0] = args;
44252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44253 if (!SWIG_IsOK(res1)) {
44254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44255 }
44256 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44257 {
44258 PyThreadState* __tstate = wxPyBeginAllowThreads();
44259 {
44260 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
44261 result = (wxBitmap *) &_result_ref;
44262 }
44263 wxPyEndAllowThreads(__tstate);
44264 if (PyErr_Occurred()) SWIG_fail;
44265 }
44266 {
44267 wxBitmap* resultptr = new wxBitmap(*result);
44268 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44269 }
44270 return resultobj;
44271 fail:
44272 return NULL;
44273 }
44274
44275
44276 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44277 PyObject *resultobj = 0;
44278 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44279 int arg2 ;
44280 void *argp1 = 0 ;
44281 int res1 = 0 ;
44282 int val2 ;
44283 int ecode2 = 0 ;
44284 PyObject * obj0 = 0 ;
44285 PyObject * obj1 = 0 ;
44286 char * kwnames[] = {
44287 (char *) "self",(char *) "nWidth", NULL
44288 };
44289
44290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44292 if (!SWIG_IsOK(res1)) {
44293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44294 }
44295 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44296 ecode2 = SWIG_AsVal_int(obj1, &val2);
44297 if (!SWIG_IsOK(ecode2)) {
44298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44299 }
44300 arg2 = static_cast< int >(val2);
44301 {
44302 PyThreadState* __tstate = wxPyBeginAllowThreads();
44303 (arg1)->SetMarginWidth(arg2);
44304 wxPyEndAllowThreads(__tstate);
44305 if (PyErr_Occurred()) SWIG_fail;
44306 }
44307 resultobj = SWIG_Py_Void();
44308 return resultobj;
44309 fail:
44310 return NULL;
44311 }
44312
44313
44314 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44315 PyObject *resultobj = 0;
44316 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44317 int result;
44318 void *argp1 = 0 ;
44319 int res1 = 0 ;
44320 PyObject *swig_obj[1] ;
44321
44322 if (!args) SWIG_fail;
44323 swig_obj[0] = args;
44324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44325 if (!SWIG_IsOK(res1)) {
44326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44327 }
44328 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44329 {
44330 PyThreadState* __tstate = wxPyBeginAllowThreads();
44331 result = (int)(arg1)->GetMarginWidth();
44332 wxPyEndAllowThreads(__tstate);
44333 if (PyErr_Occurred()) SWIG_fail;
44334 }
44335 resultobj = SWIG_From_int(static_cast< int >(result));
44336 return resultobj;
44337 fail:
44338 return NULL;
44339 }
44340
44341
44342 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44343 PyObject *resultobj = 0;
44344 int result;
44345
44346 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44347 {
44348 PyThreadState* __tstate = wxPyBeginAllowThreads();
44349 result = (int)wxMenuItem::GetDefaultMarginWidth();
44350 wxPyEndAllowThreads(__tstate);
44351 if (PyErr_Occurred()) SWIG_fail;
44352 }
44353 resultobj = SWIG_From_int(static_cast< int >(result));
44354 return resultobj;
44355 fail:
44356 return NULL;
44357 }
44358
44359
44360 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44361 PyObject *resultobj = 0;
44362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44363 bool result;
44364 void *argp1 = 0 ;
44365 int res1 = 0 ;
44366 PyObject *swig_obj[1] ;
44367
44368 if (!args) SWIG_fail;
44369 swig_obj[0] = args;
44370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44371 if (!SWIG_IsOK(res1)) {
44372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44373 }
44374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44375 {
44376 PyThreadState* __tstate = wxPyBeginAllowThreads();
44377 result = (bool)(arg1)->IsOwnerDrawn();
44378 wxPyEndAllowThreads(__tstate);
44379 if (PyErr_Occurred()) SWIG_fail;
44380 }
44381 {
44382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44383 }
44384 return resultobj;
44385 fail:
44386 return NULL;
44387 }
44388
44389
44390 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44391 PyObject *resultobj = 0;
44392 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44393 bool arg2 = (bool) true ;
44394 void *argp1 = 0 ;
44395 int res1 = 0 ;
44396 bool val2 ;
44397 int ecode2 = 0 ;
44398 PyObject * obj0 = 0 ;
44399 PyObject * obj1 = 0 ;
44400 char * kwnames[] = {
44401 (char *) "self",(char *) "ownerDrawn", NULL
44402 };
44403
44404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44406 if (!SWIG_IsOK(res1)) {
44407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44408 }
44409 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44410 if (obj1) {
44411 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44412 if (!SWIG_IsOK(ecode2)) {
44413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44414 }
44415 arg2 = static_cast< bool >(val2);
44416 }
44417 {
44418 PyThreadState* __tstate = wxPyBeginAllowThreads();
44419 (arg1)->SetOwnerDrawn(arg2);
44420 wxPyEndAllowThreads(__tstate);
44421 if (PyErr_Occurred()) SWIG_fail;
44422 }
44423 resultobj = SWIG_Py_Void();
44424 return resultobj;
44425 fail:
44426 return NULL;
44427 }
44428
44429
44430 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44431 PyObject *resultobj = 0;
44432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44433 void *argp1 = 0 ;
44434 int res1 = 0 ;
44435 PyObject *swig_obj[1] ;
44436
44437 if (!args) SWIG_fail;
44438 swig_obj[0] = args;
44439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44440 if (!SWIG_IsOK(res1)) {
44441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44442 }
44443 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44444 {
44445 PyThreadState* __tstate = wxPyBeginAllowThreads();
44446 (arg1)->ResetOwnerDrawn();
44447 wxPyEndAllowThreads(__tstate);
44448 if (PyErr_Occurred()) SWIG_fail;
44449 }
44450 resultobj = SWIG_Py_Void();
44451 return resultobj;
44452 fail:
44453 return NULL;
44454 }
44455
44456
44457 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44458 PyObject *obj;
44459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44460 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44461 return SWIG_Py_Void();
44462 }
44463
44464 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44465 return SWIG_Python_InitShadowInstance(args);
44466 }
44467
44468 SWIGINTERN int ControlNameStr_set(PyObject *) {
44469 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44470 return 1;
44471 }
44472
44473
44474 SWIGINTERN PyObject *ControlNameStr_get(void) {
44475 PyObject *pyobj = 0;
44476
44477 {
44478 #if wxUSE_UNICODE
44479 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44480 #else
44481 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44482 #endif
44483 }
44484 return pyobj;
44485 }
44486
44487
44488 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44489 PyObject *resultobj = 0;
44490 wxWindow *arg1 = (wxWindow *) 0 ;
44491 int arg2 = (int) -1 ;
44492 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44493 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44494 wxSize const &arg4_defvalue = wxDefaultSize ;
44495 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44496 long arg5 = (long) 0 ;
44497 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44498 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44499 wxString const &arg7_defvalue = wxPyControlNameStr ;
44500 wxString *arg7 = (wxString *) &arg7_defvalue ;
44501 wxControl *result = 0 ;
44502 void *argp1 = 0 ;
44503 int res1 = 0 ;
44504 int val2 ;
44505 int ecode2 = 0 ;
44506 wxPoint temp3 ;
44507 wxSize temp4 ;
44508 long val5 ;
44509 int ecode5 = 0 ;
44510 void *argp6 = 0 ;
44511 int res6 = 0 ;
44512 bool temp7 = false ;
44513 PyObject * obj0 = 0 ;
44514 PyObject * obj1 = 0 ;
44515 PyObject * obj2 = 0 ;
44516 PyObject * obj3 = 0 ;
44517 PyObject * obj4 = 0 ;
44518 PyObject * obj5 = 0 ;
44519 PyObject * obj6 = 0 ;
44520 char * kwnames[] = {
44521 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44522 };
44523
44524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44526 if (!SWIG_IsOK(res1)) {
44527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44528 }
44529 arg1 = reinterpret_cast< wxWindow * >(argp1);
44530 if (obj1) {
44531 ecode2 = SWIG_AsVal_int(obj1, &val2);
44532 if (!SWIG_IsOK(ecode2)) {
44533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44534 }
44535 arg2 = static_cast< int >(val2);
44536 }
44537 if (obj2) {
44538 {
44539 arg3 = &temp3;
44540 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44541 }
44542 }
44543 if (obj3) {
44544 {
44545 arg4 = &temp4;
44546 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44547 }
44548 }
44549 if (obj4) {
44550 ecode5 = SWIG_AsVal_long(obj4, &val5);
44551 if (!SWIG_IsOK(ecode5)) {
44552 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44553 }
44554 arg5 = static_cast< long >(val5);
44555 }
44556 if (obj5) {
44557 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44558 if (!SWIG_IsOK(res6)) {
44559 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44560 }
44561 if (!argp6) {
44562 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44563 }
44564 arg6 = reinterpret_cast< wxValidator * >(argp6);
44565 }
44566 if (obj6) {
44567 {
44568 arg7 = wxString_in_helper(obj6);
44569 if (arg7 == NULL) SWIG_fail;
44570 temp7 = true;
44571 }
44572 }
44573 {
44574 if (!wxPyCheckForApp()) SWIG_fail;
44575 PyThreadState* __tstate = wxPyBeginAllowThreads();
44576 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44577 wxPyEndAllowThreads(__tstate);
44578 if (PyErr_Occurred()) SWIG_fail;
44579 }
44580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44581 {
44582 if (temp7)
44583 delete arg7;
44584 }
44585 return resultobj;
44586 fail:
44587 {
44588 if (temp7)
44589 delete arg7;
44590 }
44591 return NULL;
44592 }
44593
44594
44595 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44596 PyObject *resultobj = 0;
44597 wxControl *result = 0 ;
44598
44599 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44600 {
44601 if (!wxPyCheckForApp()) SWIG_fail;
44602 PyThreadState* __tstate = wxPyBeginAllowThreads();
44603 result = (wxControl *)new wxControl();
44604 wxPyEndAllowThreads(__tstate);
44605 if (PyErr_Occurred()) SWIG_fail;
44606 }
44607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44608 return resultobj;
44609 fail:
44610 return NULL;
44611 }
44612
44613
44614 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44615 PyObject *resultobj = 0;
44616 wxControl *arg1 = (wxControl *) 0 ;
44617 wxWindow *arg2 = (wxWindow *) 0 ;
44618 int arg3 = (int) -1 ;
44619 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44620 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44621 wxSize const &arg5_defvalue = wxDefaultSize ;
44622 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44623 long arg6 = (long) 0 ;
44624 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44625 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44626 wxString const &arg8_defvalue = wxPyControlNameStr ;
44627 wxString *arg8 = (wxString *) &arg8_defvalue ;
44628 bool result;
44629 void *argp1 = 0 ;
44630 int res1 = 0 ;
44631 void *argp2 = 0 ;
44632 int res2 = 0 ;
44633 int val3 ;
44634 int ecode3 = 0 ;
44635 wxPoint temp4 ;
44636 wxSize temp5 ;
44637 long val6 ;
44638 int ecode6 = 0 ;
44639 void *argp7 = 0 ;
44640 int res7 = 0 ;
44641 bool temp8 = false ;
44642 PyObject * obj0 = 0 ;
44643 PyObject * obj1 = 0 ;
44644 PyObject * obj2 = 0 ;
44645 PyObject * obj3 = 0 ;
44646 PyObject * obj4 = 0 ;
44647 PyObject * obj5 = 0 ;
44648 PyObject * obj6 = 0 ;
44649 PyObject * obj7 = 0 ;
44650 char * kwnames[] = {
44651 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44652 };
44653
44654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44656 if (!SWIG_IsOK(res1)) {
44657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44658 }
44659 arg1 = reinterpret_cast< wxControl * >(argp1);
44660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44661 if (!SWIG_IsOK(res2)) {
44662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44663 }
44664 arg2 = reinterpret_cast< wxWindow * >(argp2);
44665 if (obj2) {
44666 ecode3 = SWIG_AsVal_int(obj2, &val3);
44667 if (!SWIG_IsOK(ecode3)) {
44668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44669 }
44670 arg3 = static_cast< int >(val3);
44671 }
44672 if (obj3) {
44673 {
44674 arg4 = &temp4;
44675 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44676 }
44677 }
44678 if (obj4) {
44679 {
44680 arg5 = &temp5;
44681 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44682 }
44683 }
44684 if (obj5) {
44685 ecode6 = SWIG_AsVal_long(obj5, &val6);
44686 if (!SWIG_IsOK(ecode6)) {
44687 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44688 }
44689 arg6 = static_cast< long >(val6);
44690 }
44691 if (obj6) {
44692 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44693 if (!SWIG_IsOK(res7)) {
44694 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44695 }
44696 if (!argp7) {
44697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44698 }
44699 arg7 = reinterpret_cast< wxValidator * >(argp7);
44700 }
44701 if (obj7) {
44702 {
44703 arg8 = wxString_in_helper(obj7);
44704 if (arg8 == NULL) SWIG_fail;
44705 temp8 = true;
44706 }
44707 }
44708 {
44709 PyThreadState* __tstate = wxPyBeginAllowThreads();
44710 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44711 wxPyEndAllowThreads(__tstate);
44712 if (PyErr_Occurred()) SWIG_fail;
44713 }
44714 {
44715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44716 }
44717 {
44718 if (temp8)
44719 delete arg8;
44720 }
44721 return resultobj;
44722 fail:
44723 {
44724 if (temp8)
44725 delete arg8;
44726 }
44727 return NULL;
44728 }
44729
44730
44731 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44732 PyObject *resultobj = 0;
44733 wxControl *arg1 = (wxControl *) 0 ;
44734 int result;
44735 void *argp1 = 0 ;
44736 int res1 = 0 ;
44737 PyObject *swig_obj[1] ;
44738
44739 if (!args) SWIG_fail;
44740 swig_obj[0] = args;
44741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44742 if (!SWIG_IsOK(res1)) {
44743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44744 }
44745 arg1 = reinterpret_cast< wxControl * >(argp1);
44746 {
44747 PyThreadState* __tstate = wxPyBeginAllowThreads();
44748 result = (int)((wxControl const *)arg1)->GetAlignment();
44749 wxPyEndAllowThreads(__tstate);
44750 if (PyErr_Occurred()) SWIG_fail;
44751 }
44752 resultobj = SWIG_From_int(static_cast< int >(result));
44753 return resultobj;
44754 fail:
44755 return NULL;
44756 }
44757
44758
44759 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44760 PyObject *resultobj = 0;
44761 wxControl *arg1 = (wxControl *) 0 ;
44762 wxString result;
44763 void *argp1 = 0 ;
44764 int res1 = 0 ;
44765 PyObject *swig_obj[1] ;
44766
44767 if (!args) SWIG_fail;
44768 swig_obj[0] = args;
44769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44770 if (!SWIG_IsOK(res1)) {
44771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44772 }
44773 arg1 = reinterpret_cast< wxControl * >(argp1);
44774 {
44775 PyThreadState* __tstate = wxPyBeginAllowThreads();
44776 result = ((wxControl const *)arg1)->GetLabelText();
44777 wxPyEndAllowThreads(__tstate);
44778 if (PyErr_Occurred()) SWIG_fail;
44779 }
44780 {
44781 #if wxUSE_UNICODE
44782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44783 #else
44784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44785 #endif
44786 }
44787 return resultobj;
44788 fail:
44789 return NULL;
44790 }
44791
44792
44793 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44794 PyObject *resultobj = 0;
44795 wxControl *arg1 = (wxControl *) 0 ;
44796 wxCommandEvent *arg2 = 0 ;
44797 void *argp1 = 0 ;
44798 int res1 = 0 ;
44799 void *argp2 = 0 ;
44800 int res2 = 0 ;
44801 PyObject * obj0 = 0 ;
44802 PyObject * obj1 = 0 ;
44803 char * kwnames[] = {
44804 (char *) "self",(char *) "event", NULL
44805 };
44806
44807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44809 if (!SWIG_IsOK(res1)) {
44810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44811 }
44812 arg1 = reinterpret_cast< wxControl * >(argp1);
44813 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44814 if (!SWIG_IsOK(res2)) {
44815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44816 }
44817 if (!argp2) {
44818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44819 }
44820 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44821 {
44822 PyThreadState* __tstate = wxPyBeginAllowThreads();
44823 (arg1)->Command(*arg2);
44824 wxPyEndAllowThreads(__tstate);
44825 if (PyErr_Occurred()) SWIG_fail;
44826 }
44827 resultobj = SWIG_Py_Void();
44828 return resultobj;
44829 fail:
44830 return NULL;
44831 }
44832
44833
44834 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44835 PyObject *resultobj = 0;
44836 wxControl *arg1 = (wxControl *) 0 ;
44837 wxString result;
44838 void *argp1 = 0 ;
44839 int res1 = 0 ;
44840 PyObject *swig_obj[1] ;
44841
44842 if (!args) SWIG_fail;
44843 swig_obj[0] = args;
44844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44845 if (!SWIG_IsOK(res1)) {
44846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44847 }
44848 arg1 = reinterpret_cast< wxControl * >(argp1);
44849 {
44850 PyThreadState* __tstate = wxPyBeginAllowThreads();
44851 result = (arg1)->GetLabel();
44852 wxPyEndAllowThreads(__tstate);
44853 if (PyErr_Occurred()) SWIG_fail;
44854 }
44855 {
44856 #if wxUSE_UNICODE
44857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44858 #else
44859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44860 #endif
44861 }
44862 return resultobj;
44863 fail:
44864 return NULL;
44865 }
44866
44867
44868 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44869 PyObject *resultobj = 0;
44870 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44871 SwigValueWrapper<wxVisualAttributes > result;
44872 int val1 ;
44873 int ecode1 = 0 ;
44874 PyObject * obj0 = 0 ;
44875 char * kwnames[] = {
44876 (char *) "variant", NULL
44877 };
44878
44879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44880 if (obj0) {
44881 ecode1 = SWIG_AsVal_int(obj0, &val1);
44882 if (!SWIG_IsOK(ecode1)) {
44883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44884 }
44885 arg1 = static_cast< wxWindowVariant >(val1);
44886 }
44887 {
44888 if (!wxPyCheckForApp()) SWIG_fail;
44889 PyThreadState* __tstate = wxPyBeginAllowThreads();
44890 result = wxControl::GetClassDefaultAttributes(arg1);
44891 wxPyEndAllowThreads(__tstate);
44892 if (PyErr_Occurred()) SWIG_fail;
44893 }
44894 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44895 return resultobj;
44896 fail:
44897 return NULL;
44898 }
44899
44900
44901 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44902 PyObject *obj;
44903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44904 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44905 return SWIG_Py_Void();
44906 }
44907
44908 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44909 return SWIG_Python_InitShadowInstance(args);
44910 }
44911
44912 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44913 PyObject *resultobj = 0;
44914 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44915 wxString *arg2 = 0 ;
44916 PyObject *arg3 = (PyObject *) NULL ;
44917 int result;
44918 void *argp1 = 0 ;
44919 int res1 = 0 ;
44920 bool temp2 = false ;
44921 PyObject * obj0 = 0 ;
44922 PyObject * obj1 = 0 ;
44923 PyObject * obj2 = 0 ;
44924 char * kwnames[] = {
44925 (char *) "self",(char *) "item",(char *) "clientData", NULL
44926 };
44927
44928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44930 if (!SWIG_IsOK(res1)) {
44931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44932 }
44933 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44934 {
44935 arg2 = wxString_in_helper(obj1);
44936 if (arg2 == NULL) SWIG_fail;
44937 temp2 = true;
44938 }
44939 if (obj2) {
44940 arg3 = obj2;
44941 }
44942 {
44943 PyThreadState* __tstate = wxPyBeginAllowThreads();
44944 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44945 wxPyEndAllowThreads(__tstate);
44946 if (PyErr_Occurred()) SWIG_fail;
44947 }
44948 resultobj = SWIG_From_int(static_cast< int >(result));
44949 {
44950 if (temp2)
44951 delete arg2;
44952 }
44953 return resultobj;
44954 fail:
44955 {
44956 if (temp2)
44957 delete arg2;
44958 }
44959 return NULL;
44960 }
44961
44962
44963 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44964 PyObject *resultobj = 0;
44965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44966 wxArrayString *arg2 = 0 ;
44967 void *argp1 = 0 ;
44968 int res1 = 0 ;
44969 bool temp2 = false ;
44970 PyObject * obj0 = 0 ;
44971 PyObject * obj1 = 0 ;
44972 char * kwnames[] = {
44973 (char *) "self",(char *) "strings", NULL
44974 };
44975
44976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44978 if (!SWIG_IsOK(res1)) {
44979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44980 }
44981 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44982 {
44983 if (! PySequence_Check(obj1)) {
44984 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44985 SWIG_fail;
44986 }
44987 arg2 = new wxArrayString;
44988 temp2 = true;
44989 int i, len=PySequence_Length(obj1);
44990 for (i=0; i<len; i++) {
44991 PyObject* item = PySequence_GetItem(obj1, i);
44992 wxString* s = wxString_in_helper(item);
44993 if (PyErr_Occurred()) SWIG_fail;
44994 arg2->Add(*s);
44995 delete s;
44996 Py_DECREF(item);
44997 }
44998 }
44999 {
45000 PyThreadState* __tstate = wxPyBeginAllowThreads();
45001 (arg1)->Append((wxArrayString const &)*arg2);
45002 wxPyEndAllowThreads(__tstate);
45003 if (PyErr_Occurred()) SWIG_fail;
45004 }
45005 resultobj = SWIG_Py_Void();
45006 {
45007 if (temp2) delete arg2;
45008 }
45009 return resultobj;
45010 fail:
45011 {
45012 if (temp2) delete arg2;
45013 }
45014 return NULL;
45015 }
45016
45017
45018 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45019 PyObject *resultobj = 0;
45020 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45021 wxString *arg2 = 0 ;
45022 unsigned int arg3 ;
45023 PyObject *arg4 = (PyObject *) NULL ;
45024 int result;
45025 void *argp1 = 0 ;
45026 int res1 = 0 ;
45027 bool temp2 = false ;
45028 unsigned int val3 ;
45029 int ecode3 = 0 ;
45030 PyObject * obj0 = 0 ;
45031 PyObject * obj1 = 0 ;
45032 PyObject * obj2 = 0 ;
45033 PyObject * obj3 = 0 ;
45034 char * kwnames[] = {
45035 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45036 };
45037
45038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45040 if (!SWIG_IsOK(res1)) {
45041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45042 }
45043 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45044 {
45045 arg2 = wxString_in_helper(obj1);
45046 if (arg2 == NULL) SWIG_fail;
45047 temp2 = true;
45048 }
45049 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45050 if (!SWIG_IsOK(ecode3)) {
45051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45052 }
45053 arg3 = static_cast< unsigned int >(val3);
45054 if (obj3) {
45055 arg4 = obj3;
45056 }
45057 {
45058 PyThreadState* __tstate = wxPyBeginAllowThreads();
45059 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45060 wxPyEndAllowThreads(__tstate);
45061 if (PyErr_Occurred()) SWIG_fail;
45062 }
45063 resultobj = SWIG_From_int(static_cast< int >(result));
45064 {
45065 if (temp2)
45066 delete arg2;
45067 }
45068 return resultobj;
45069 fail:
45070 {
45071 if (temp2)
45072 delete arg2;
45073 }
45074 return NULL;
45075 }
45076
45077
45078 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45079 PyObject *resultobj = 0;
45080 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45081 void *argp1 = 0 ;
45082 int res1 = 0 ;
45083 PyObject *swig_obj[1] ;
45084
45085 if (!args) SWIG_fail;
45086 swig_obj[0] = args;
45087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45088 if (!SWIG_IsOK(res1)) {
45089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45090 }
45091 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45092 {
45093 PyThreadState* __tstate = wxPyBeginAllowThreads();
45094 (arg1)->Clear();
45095 wxPyEndAllowThreads(__tstate);
45096 if (PyErr_Occurred()) SWIG_fail;
45097 }
45098 resultobj = SWIG_Py_Void();
45099 return resultobj;
45100 fail:
45101 return NULL;
45102 }
45103
45104
45105 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45106 PyObject *resultobj = 0;
45107 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45108 unsigned int arg2 ;
45109 void *argp1 = 0 ;
45110 int res1 = 0 ;
45111 unsigned int val2 ;
45112 int ecode2 = 0 ;
45113 PyObject * obj0 = 0 ;
45114 PyObject * obj1 = 0 ;
45115 char * kwnames[] = {
45116 (char *) "self",(char *) "n", NULL
45117 };
45118
45119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45121 if (!SWIG_IsOK(res1)) {
45122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45123 }
45124 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45125 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45126 if (!SWIG_IsOK(ecode2)) {
45127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45128 }
45129 arg2 = static_cast< unsigned int >(val2);
45130 {
45131 PyThreadState* __tstate = wxPyBeginAllowThreads();
45132 (arg1)->Delete(arg2);
45133 wxPyEndAllowThreads(__tstate);
45134 if (PyErr_Occurred()) SWIG_fail;
45135 }
45136 resultobj = SWIG_Py_Void();
45137 return resultobj;
45138 fail:
45139 return NULL;
45140 }
45141
45142
45143 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45144 PyObject *resultobj = 0;
45145 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45146 unsigned int arg2 ;
45147 PyObject *result = 0 ;
45148 void *argp1 = 0 ;
45149 int res1 = 0 ;
45150 unsigned int val2 ;
45151 int ecode2 = 0 ;
45152 PyObject * obj0 = 0 ;
45153 PyObject * obj1 = 0 ;
45154 char * kwnames[] = {
45155 (char *) "self",(char *) "n", NULL
45156 };
45157
45158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45160 if (!SWIG_IsOK(res1)) {
45161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45162 }
45163 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45164 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45165 if (!SWIG_IsOK(ecode2)) {
45166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45167 }
45168 arg2 = static_cast< unsigned int >(val2);
45169 {
45170 PyThreadState* __tstate = wxPyBeginAllowThreads();
45171 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45172 wxPyEndAllowThreads(__tstate);
45173 if (PyErr_Occurred()) SWIG_fail;
45174 }
45175 resultobj = result;
45176 return resultobj;
45177 fail:
45178 return NULL;
45179 }
45180
45181
45182 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45183 PyObject *resultobj = 0;
45184 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45185 unsigned int arg2 ;
45186 PyObject *arg3 = (PyObject *) 0 ;
45187 void *argp1 = 0 ;
45188 int res1 = 0 ;
45189 unsigned int val2 ;
45190 int ecode2 = 0 ;
45191 PyObject * obj0 = 0 ;
45192 PyObject * obj1 = 0 ;
45193 PyObject * obj2 = 0 ;
45194 char * kwnames[] = {
45195 (char *) "self",(char *) "n",(char *) "clientData", NULL
45196 };
45197
45198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45200 if (!SWIG_IsOK(res1)) {
45201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45202 }
45203 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45204 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45205 if (!SWIG_IsOK(ecode2)) {
45206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45207 }
45208 arg2 = static_cast< unsigned int >(val2);
45209 arg3 = obj2;
45210 {
45211 PyThreadState* __tstate = wxPyBeginAllowThreads();
45212 wxItemContainer_SetClientData(arg1,arg2,arg3);
45213 wxPyEndAllowThreads(__tstate);
45214 if (PyErr_Occurred()) SWIG_fail;
45215 }
45216 resultobj = SWIG_Py_Void();
45217 return resultobj;
45218 fail:
45219 return NULL;
45220 }
45221
45222
45223 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45224 PyObject *resultobj = 0;
45225 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45226 unsigned int result;
45227 void *argp1 = 0 ;
45228 int res1 = 0 ;
45229 PyObject *swig_obj[1] ;
45230
45231 if (!args) SWIG_fail;
45232 swig_obj[0] = args;
45233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45234 if (!SWIG_IsOK(res1)) {
45235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45236 }
45237 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45238 {
45239 PyThreadState* __tstate = wxPyBeginAllowThreads();
45240 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45241 wxPyEndAllowThreads(__tstate);
45242 if (PyErr_Occurred()) SWIG_fail;
45243 }
45244 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45245 return resultobj;
45246 fail:
45247 return NULL;
45248 }
45249
45250
45251 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45252 PyObject *resultobj = 0;
45253 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45254 bool result;
45255 void *argp1 = 0 ;
45256 int res1 = 0 ;
45257 PyObject *swig_obj[1] ;
45258
45259 if (!args) SWIG_fail;
45260 swig_obj[0] = args;
45261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45262 if (!SWIG_IsOK(res1)) {
45263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45264 }
45265 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45266 {
45267 PyThreadState* __tstate = wxPyBeginAllowThreads();
45268 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45269 wxPyEndAllowThreads(__tstate);
45270 if (PyErr_Occurred()) SWIG_fail;
45271 }
45272 {
45273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45274 }
45275 return resultobj;
45276 fail:
45277 return NULL;
45278 }
45279
45280
45281 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45282 PyObject *resultobj = 0;
45283 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45284 unsigned int arg2 ;
45285 wxString result;
45286 void *argp1 = 0 ;
45287 int res1 = 0 ;
45288 unsigned int val2 ;
45289 int ecode2 = 0 ;
45290 PyObject * obj0 = 0 ;
45291 PyObject * obj1 = 0 ;
45292 char * kwnames[] = {
45293 (char *) "self",(char *) "n", NULL
45294 };
45295
45296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45298 if (!SWIG_IsOK(res1)) {
45299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45300 }
45301 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45302 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45303 if (!SWIG_IsOK(ecode2)) {
45304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45305 }
45306 arg2 = static_cast< unsigned int >(val2);
45307 {
45308 PyThreadState* __tstate = wxPyBeginAllowThreads();
45309 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45310 wxPyEndAllowThreads(__tstate);
45311 if (PyErr_Occurred()) SWIG_fail;
45312 }
45313 {
45314 #if wxUSE_UNICODE
45315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45316 #else
45317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45318 #endif
45319 }
45320 return resultobj;
45321 fail:
45322 return NULL;
45323 }
45324
45325
45326 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45327 PyObject *resultobj = 0;
45328 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45329 wxArrayString result;
45330 void *argp1 = 0 ;
45331 int res1 = 0 ;
45332 PyObject *swig_obj[1] ;
45333
45334 if (!args) SWIG_fail;
45335 swig_obj[0] = args;
45336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45337 if (!SWIG_IsOK(res1)) {
45338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45339 }
45340 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45341 {
45342 PyThreadState* __tstate = wxPyBeginAllowThreads();
45343 result = ((wxItemContainer const *)arg1)->GetStrings();
45344 wxPyEndAllowThreads(__tstate);
45345 if (PyErr_Occurred()) SWIG_fail;
45346 }
45347 {
45348 resultobj = wxArrayString2PyList_helper(result);
45349 }
45350 return resultobj;
45351 fail:
45352 return NULL;
45353 }
45354
45355
45356 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45357 PyObject *resultobj = 0;
45358 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45359 unsigned int arg2 ;
45360 wxString *arg3 = 0 ;
45361 void *argp1 = 0 ;
45362 int res1 = 0 ;
45363 unsigned int val2 ;
45364 int ecode2 = 0 ;
45365 bool temp3 = false ;
45366 PyObject * obj0 = 0 ;
45367 PyObject * obj1 = 0 ;
45368 PyObject * obj2 = 0 ;
45369 char * kwnames[] = {
45370 (char *) "self",(char *) "n",(char *) "s", NULL
45371 };
45372
45373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45375 if (!SWIG_IsOK(res1)) {
45376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45377 }
45378 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45379 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45380 if (!SWIG_IsOK(ecode2)) {
45381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45382 }
45383 arg2 = static_cast< unsigned int >(val2);
45384 {
45385 arg3 = wxString_in_helper(obj2);
45386 if (arg3 == NULL) SWIG_fail;
45387 temp3 = true;
45388 }
45389 {
45390 PyThreadState* __tstate = wxPyBeginAllowThreads();
45391 (arg1)->SetString(arg2,(wxString const &)*arg3);
45392 wxPyEndAllowThreads(__tstate);
45393 if (PyErr_Occurred()) SWIG_fail;
45394 }
45395 resultobj = SWIG_Py_Void();
45396 {
45397 if (temp3)
45398 delete arg3;
45399 }
45400 return resultobj;
45401 fail:
45402 {
45403 if (temp3)
45404 delete arg3;
45405 }
45406 return NULL;
45407 }
45408
45409
45410 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45411 PyObject *resultobj = 0;
45412 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45413 wxString *arg2 = 0 ;
45414 int result;
45415 void *argp1 = 0 ;
45416 int res1 = 0 ;
45417 bool temp2 = false ;
45418 PyObject * obj0 = 0 ;
45419 PyObject * obj1 = 0 ;
45420 char * kwnames[] = {
45421 (char *) "self",(char *) "s", NULL
45422 };
45423
45424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45426 if (!SWIG_IsOK(res1)) {
45427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45428 }
45429 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45430 {
45431 arg2 = wxString_in_helper(obj1);
45432 if (arg2 == NULL) SWIG_fail;
45433 temp2 = true;
45434 }
45435 {
45436 PyThreadState* __tstate = wxPyBeginAllowThreads();
45437 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45438 wxPyEndAllowThreads(__tstate);
45439 if (PyErr_Occurred()) SWIG_fail;
45440 }
45441 resultobj = SWIG_From_int(static_cast< int >(result));
45442 {
45443 if (temp2)
45444 delete arg2;
45445 }
45446 return resultobj;
45447 fail:
45448 {
45449 if (temp2)
45450 delete arg2;
45451 }
45452 return NULL;
45453 }
45454
45455
45456 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45457 PyObject *resultobj = 0;
45458 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45459 int arg2 ;
45460 void *argp1 = 0 ;
45461 int res1 = 0 ;
45462 int val2 ;
45463 int ecode2 = 0 ;
45464 PyObject * obj0 = 0 ;
45465 PyObject * obj1 = 0 ;
45466 char * kwnames[] = {
45467 (char *) "self",(char *) "n", NULL
45468 };
45469
45470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45472 if (!SWIG_IsOK(res1)) {
45473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45474 }
45475 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45476 ecode2 = SWIG_AsVal_int(obj1, &val2);
45477 if (!SWIG_IsOK(ecode2)) {
45478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45479 }
45480 arg2 = static_cast< int >(val2);
45481 {
45482 PyThreadState* __tstate = wxPyBeginAllowThreads();
45483 (arg1)->SetSelection(arg2);
45484 wxPyEndAllowThreads(__tstate);
45485 if (PyErr_Occurred()) SWIG_fail;
45486 }
45487 resultobj = SWIG_Py_Void();
45488 return resultobj;
45489 fail:
45490 return NULL;
45491 }
45492
45493
45494 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45495 PyObject *resultobj = 0;
45496 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45497 int result;
45498 void *argp1 = 0 ;
45499 int res1 = 0 ;
45500 PyObject *swig_obj[1] ;
45501
45502 if (!args) SWIG_fail;
45503 swig_obj[0] = args;
45504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45505 if (!SWIG_IsOK(res1)) {
45506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45507 }
45508 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45509 {
45510 PyThreadState* __tstate = wxPyBeginAllowThreads();
45511 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45512 wxPyEndAllowThreads(__tstate);
45513 if (PyErr_Occurred()) SWIG_fail;
45514 }
45515 resultobj = SWIG_From_int(static_cast< int >(result));
45516 return resultobj;
45517 fail:
45518 return NULL;
45519 }
45520
45521
45522 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45523 PyObject *resultobj = 0;
45524 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45525 wxString *arg2 = 0 ;
45526 bool result;
45527 void *argp1 = 0 ;
45528 int res1 = 0 ;
45529 bool temp2 = false ;
45530 PyObject * obj0 = 0 ;
45531 PyObject * obj1 = 0 ;
45532 char * kwnames[] = {
45533 (char *) "self",(char *) "s", NULL
45534 };
45535
45536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45538 if (!SWIG_IsOK(res1)) {
45539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45540 }
45541 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45542 {
45543 arg2 = wxString_in_helper(obj1);
45544 if (arg2 == NULL) SWIG_fail;
45545 temp2 = true;
45546 }
45547 {
45548 PyThreadState* __tstate = wxPyBeginAllowThreads();
45549 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45550 wxPyEndAllowThreads(__tstate);
45551 if (PyErr_Occurred()) SWIG_fail;
45552 }
45553 {
45554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45555 }
45556 {
45557 if (temp2)
45558 delete arg2;
45559 }
45560 return resultobj;
45561 fail:
45562 {
45563 if (temp2)
45564 delete arg2;
45565 }
45566 return NULL;
45567 }
45568
45569
45570 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45571 PyObject *resultobj = 0;
45572 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45573 wxString result;
45574 void *argp1 = 0 ;
45575 int res1 = 0 ;
45576 PyObject *swig_obj[1] ;
45577
45578 if (!args) SWIG_fail;
45579 swig_obj[0] = args;
45580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45581 if (!SWIG_IsOK(res1)) {
45582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45583 }
45584 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45585 {
45586 PyThreadState* __tstate = wxPyBeginAllowThreads();
45587 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45588 wxPyEndAllowThreads(__tstate);
45589 if (PyErr_Occurred()) SWIG_fail;
45590 }
45591 {
45592 #if wxUSE_UNICODE
45593 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45594 #else
45595 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45596 #endif
45597 }
45598 return resultobj;
45599 fail:
45600 return NULL;
45601 }
45602
45603
45604 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45605 PyObject *resultobj = 0;
45606 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45607 int arg2 ;
45608 void *argp1 = 0 ;
45609 int res1 = 0 ;
45610 int val2 ;
45611 int ecode2 = 0 ;
45612 PyObject * obj0 = 0 ;
45613 PyObject * obj1 = 0 ;
45614 char * kwnames[] = {
45615 (char *) "self",(char *) "n", NULL
45616 };
45617
45618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45620 if (!SWIG_IsOK(res1)) {
45621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45622 }
45623 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45624 ecode2 = SWIG_AsVal_int(obj1, &val2);
45625 if (!SWIG_IsOK(ecode2)) {
45626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45627 }
45628 arg2 = static_cast< int >(val2);
45629 {
45630 PyThreadState* __tstate = wxPyBeginAllowThreads();
45631 (arg1)->Select(arg2);
45632 wxPyEndAllowThreads(__tstate);
45633 if (PyErr_Occurred()) SWIG_fail;
45634 }
45635 resultobj = SWIG_Py_Void();
45636 return resultobj;
45637 fail:
45638 return NULL;
45639 }
45640
45641
45642 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45643 PyObject *obj;
45644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45645 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45646 return SWIG_Py_Void();
45647 }
45648
45649 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45650 PyObject *obj;
45651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45652 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45653 return SWIG_Py_Void();
45654 }
45655
45656 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45657 PyObject *resultobj = 0;
45658 wxSizerItem *result = 0 ;
45659
45660 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45661 {
45662 PyThreadState* __tstate = wxPyBeginAllowThreads();
45663 result = (wxSizerItem *)new wxSizerItem();
45664 wxPyEndAllowThreads(__tstate);
45665 if (PyErr_Occurred()) SWIG_fail;
45666 }
45667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45668 return resultobj;
45669 fail:
45670 return NULL;
45671 }
45672
45673
45674 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45675 PyObject *resultobj = 0;
45676 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45677 void *argp1 = 0 ;
45678 int res1 = 0 ;
45679 PyObject *swig_obj[1] ;
45680
45681 if (!args) SWIG_fail;
45682 swig_obj[0] = args;
45683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45684 if (!SWIG_IsOK(res1)) {
45685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45686 }
45687 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45688 {
45689 PyThreadState* __tstate = wxPyBeginAllowThreads();
45690 delete arg1;
45691
45692 wxPyEndAllowThreads(__tstate);
45693 if (PyErr_Occurred()) SWIG_fail;
45694 }
45695 resultobj = SWIG_Py_Void();
45696 return resultobj;
45697 fail:
45698 return NULL;
45699 }
45700
45701
45702 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45703 PyObject *resultobj = 0;
45704 wxWindow *arg1 = (wxWindow *) 0 ;
45705 int arg2 ;
45706 int arg3 ;
45707 int arg4 ;
45708 PyObject *arg5 = (PyObject *) NULL ;
45709 wxSizerItem *result = 0 ;
45710 void *argp1 = 0 ;
45711 int res1 = 0 ;
45712 int val2 ;
45713 int ecode2 = 0 ;
45714 int val3 ;
45715 int ecode3 = 0 ;
45716 int val4 ;
45717 int ecode4 = 0 ;
45718 PyObject * obj0 = 0 ;
45719 PyObject * obj1 = 0 ;
45720 PyObject * obj2 = 0 ;
45721 PyObject * obj3 = 0 ;
45722 PyObject * obj4 = 0 ;
45723 char * kwnames[] = {
45724 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45725 };
45726
45727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45729 if (!SWIG_IsOK(res1)) {
45730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45731 }
45732 arg1 = reinterpret_cast< wxWindow * >(argp1);
45733 ecode2 = SWIG_AsVal_int(obj1, &val2);
45734 if (!SWIG_IsOK(ecode2)) {
45735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45736 }
45737 arg2 = static_cast< int >(val2);
45738 ecode3 = SWIG_AsVal_int(obj2, &val3);
45739 if (!SWIG_IsOK(ecode3)) {
45740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45741 }
45742 arg3 = static_cast< int >(val3);
45743 ecode4 = SWIG_AsVal_int(obj3, &val4);
45744 if (!SWIG_IsOK(ecode4)) {
45745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45746 }
45747 arg4 = static_cast< int >(val4);
45748 if (obj4) {
45749 arg5 = obj4;
45750 }
45751 {
45752 PyThreadState* __tstate = wxPyBeginAllowThreads();
45753 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45754 wxPyEndAllowThreads(__tstate);
45755 if (PyErr_Occurred()) SWIG_fail;
45756 }
45757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45758 return resultobj;
45759 fail:
45760 return NULL;
45761 }
45762
45763
45764 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45765 PyObject *resultobj = 0;
45766 int arg1 ;
45767 int arg2 ;
45768 int arg3 ;
45769 int arg4 ;
45770 int arg5 ;
45771 PyObject *arg6 = (PyObject *) NULL ;
45772 wxSizerItem *result = 0 ;
45773 int val1 ;
45774 int ecode1 = 0 ;
45775 int val2 ;
45776 int ecode2 = 0 ;
45777 int val3 ;
45778 int ecode3 = 0 ;
45779 int val4 ;
45780 int ecode4 = 0 ;
45781 int val5 ;
45782 int ecode5 = 0 ;
45783 PyObject * obj0 = 0 ;
45784 PyObject * obj1 = 0 ;
45785 PyObject * obj2 = 0 ;
45786 PyObject * obj3 = 0 ;
45787 PyObject * obj4 = 0 ;
45788 PyObject * obj5 = 0 ;
45789 char * kwnames[] = {
45790 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45791 };
45792
45793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45794 ecode1 = SWIG_AsVal_int(obj0, &val1);
45795 if (!SWIG_IsOK(ecode1)) {
45796 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45797 }
45798 arg1 = static_cast< int >(val1);
45799 ecode2 = SWIG_AsVal_int(obj1, &val2);
45800 if (!SWIG_IsOK(ecode2)) {
45801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45802 }
45803 arg2 = static_cast< int >(val2);
45804 ecode3 = SWIG_AsVal_int(obj2, &val3);
45805 if (!SWIG_IsOK(ecode3)) {
45806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45807 }
45808 arg3 = static_cast< int >(val3);
45809 ecode4 = SWIG_AsVal_int(obj3, &val4);
45810 if (!SWIG_IsOK(ecode4)) {
45811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45812 }
45813 arg4 = static_cast< int >(val4);
45814 ecode5 = SWIG_AsVal_int(obj4, &val5);
45815 if (!SWIG_IsOK(ecode5)) {
45816 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45817 }
45818 arg5 = static_cast< int >(val5);
45819 if (obj5) {
45820 arg6 = obj5;
45821 }
45822 {
45823 PyThreadState* __tstate = wxPyBeginAllowThreads();
45824 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45825 wxPyEndAllowThreads(__tstate);
45826 if (PyErr_Occurred()) SWIG_fail;
45827 }
45828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45829 return resultobj;
45830 fail:
45831 return NULL;
45832 }
45833
45834
45835 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45836 PyObject *resultobj = 0;
45837 wxSizer *arg1 = (wxSizer *) 0 ;
45838 int arg2 ;
45839 int arg3 ;
45840 int arg4 ;
45841 PyObject *arg5 = (PyObject *) NULL ;
45842 wxSizerItem *result = 0 ;
45843 int res1 = 0 ;
45844 int val2 ;
45845 int ecode2 = 0 ;
45846 int val3 ;
45847 int ecode3 = 0 ;
45848 int val4 ;
45849 int ecode4 = 0 ;
45850 PyObject * obj0 = 0 ;
45851 PyObject * obj1 = 0 ;
45852 PyObject * obj2 = 0 ;
45853 PyObject * obj3 = 0 ;
45854 PyObject * obj4 = 0 ;
45855 char * kwnames[] = {
45856 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45857 };
45858
45859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45860 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45861 if (!SWIG_IsOK(res1)) {
45862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45863 }
45864 ecode2 = SWIG_AsVal_int(obj1, &val2);
45865 if (!SWIG_IsOK(ecode2)) {
45866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45867 }
45868 arg2 = static_cast< int >(val2);
45869 ecode3 = SWIG_AsVal_int(obj2, &val3);
45870 if (!SWIG_IsOK(ecode3)) {
45871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45872 }
45873 arg3 = static_cast< int >(val3);
45874 ecode4 = SWIG_AsVal_int(obj3, &val4);
45875 if (!SWIG_IsOK(ecode4)) {
45876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45877 }
45878 arg4 = static_cast< int >(val4);
45879 if (obj4) {
45880 arg5 = obj4;
45881 }
45882 {
45883 PyThreadState* __tstate = wxPyBeginAllowThreads();
45884 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45885 wxPyEndAllowThreads(__tstate);
45886 if (PyErr_Occurred()) SWIG_fail;
45887 }
45888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45889 return resultobj;
45890 fail:
45891 return NULL;
45892 }
45893
45894
45895 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45896 PyObject *resultobj = 0;
45897 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45898 void *argp1 = 0 ;
45899 int res1 = 0 ;
45900 PyObject *swig_obj[1] ;
45901
45902 if (!args) SWIG_fail;
45903 swig_obj[0] = args;
45904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45905 if (!SWIG_IsOK(res1)) {
45906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45907 }
45908 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45909 {
45910 PyThreadState* __tstate = wxPyBeginAllowThreads();
45911 (arg1)->DeleteWindows();
45912 wxPyEndAllowThreads(__tstate);
45913 if (PyErr_Occurred()) SWIG_fail;
45914 }
45915 resultobj = SWIG_Py_Void();
45916 return resultobj;
45917 fail:
45918 return NULL;
45919 }
45920
45921
45922 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45923 PyObject *resultobj = 0;
45924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45925 void *argp1 = 0 ;
45926 int res1 = 0 ;
45927 PyObject *swig_obj[1] ;
45928
45929 if (!args) SWIG_fail;
45930 swig_obj[0] = args;
45931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45932 if (!SWIG_IsOK(res1)) {
45933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45934 }
45935 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45936 {
45937 PyThreadState* __tstate = wxPyBeginAllowThreads();
45938 (arg1)->DetachSizer();
45939 wxPyEndAllowThreads(__tstate);
45940 if (PyErr_Occurred()) SWIG_fail;
45941 }
45942 resultobj = SWIG_Py_Void();
45943 return resultobj;
45944 fail:
45945 return NULL;
45946 }
45947
45948
45949 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45950 PyObject *resultobj = 0;
45951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45952 wxSize result;
45953 void *argp1 = 0 ;
45954 int res1 = 0 ;
45955 PyObject *swig_obj[1] ;
45956
45957 if (!args) SWIG_fail;
45958 swig_obj[0] = args;
45959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45960 if (!SWIG_IsOK(res1)) {
45961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45962 }
45963 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45964 {
45965 PyThreadState* __tstate = wxPyBeginAllowThreads();
45966 result = (arg1)->GetSize();
45967 wxPyEndAllowThreads(__tstate);
45968 if (PyErr_Occurred()) SWIG_fail;
45969 }
45970 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45971 return resultobj;
45972 fail:
45973 return NULL;
45974 }
45975
45976
45977 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45978 PyObject *resultobj = 0;
45979 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45980 wxSize result;
45981 void *argp1 = 0 ;
45982 int res1 = 0 ;
45983 PyObject *swig_obj[1] ;
45984
45985 if (!args) SWIG_fail;
45986 swig_obj[0] = args;
45987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45988 if (!SWIG_IsOK(res1)) {
45989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45990 }
45991 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45992 {
45993 PyThreadState* __tstate = wxPyBeginAllowThreads();
45994 result = (arg1)->CalcMin();
45995 wxPyEndAllowThreads(__tstate);
45996 if (PyErr_Occurred()) SWIG_fail;
45997 }
45998 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45999 return resultobj;
46000 fail:
46001 return NULL;
46002 }
46003
46004
46005 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46006 PyObject *resultobj = 0;
46007 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46008 wxPoint *arg2 = 0 ;
46009 wxSize *arg3 = 0 ;
46010 void *argp1 = 0 ;
46011 int res1 = 0 ;
46012 wxPoint temp2 ;
46013 wxSize temp3 ;
46014 PyObject * obj0 = 0 ;
46015 PyObject * obj1 = 0 ;
46016 PyObject * obj2 = 0 ;
46017 char * kwnames[] = {
46018 (char *) "self",(char *) "pos",(char *) "size", NULL
46019 };
46020
46021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46023 if (!SWIG_IsOK(res1)) {
46024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46025 }
46026 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46027 {
46028 arg2 = &temp2;
46029 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46030 }
46031 {
46032 arg3 = &temp3;
46033 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46034 }
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46038 wxPyEndAllowThreads(__tstate);
46039 if (PyErr_Occurred()) SWIG_fail;
46040 }
46041 resultobj = SWIG_Py_Void();
46042 return resultobj;
46043 fail:
46044 return NULL;
46045 }
46046
46047
46048 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46049 PyObject *resultobj = 0;
46050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46051 wxSize result;
46052 void *argp1 = 0 ;
46053 int res1 = 0 ;
46054 PyObject *swig_obj[1] ;
46055
46056 if (!args) SWIG_fail;
46057 swig_obj[0] = args;
46058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46059 if (!SWIG_IsOK(res1)) {
46060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46061 }
46062 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 result = (arg1)->GetMinSize();
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46070 return resultobj;
46071 fail:
46072 return NULL;
46073 }
46074
46075
46076 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46077 PyObject *resultobj = 0;
46078 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46079 wxSize result;
46080 void *argp1 = 0 ;
46081 int res1 = 0 ;
46082 PyObject *swig_obj[1] ;
46083
46084 if (!args) SWIG_fail;
46085 swig_obj[0] = args;
46086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46087 if (!SWIG_IsOK(res1)) {
46088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46089 }
46090 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46091 {
46092 PyThreadState* __tstate = wxPyBeginAllowThreads();
46093 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46094 wxPyEndAllowThreads(__tstate);
46095 if (PyErr_Occurred()) SWIG_fail;
46096 }
46097 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46098 return resultobj;
46099 fail:
46100 return NULL;
46101 }
46102
46103
46104 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46105 PyObject *resultobj = 0;
46106 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46107 int arg2 ;
46108 int arg3 ;
46109 void *argp1 = 0 ;
46110 int res1 = 0 ;
46111 int val2 ;
46112 int ecode2 = 0 ;
46113 int val3 ;
46114 int ecode3 = 0 ;
46115 PyObject * obj0 = 0 ;
46116 PyObject * obj1 = 0 ;
46117 PyObject * obj2 = 0 ;
46118 char * kwnames[] = {
46119 (char *) "self",(char *) "x",(char *) "y", NULL
46120 };
46121
46122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46124 if (!SWIG_IsOK(res1)) {
46125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46126 }
46127 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46128 ecode2 = SWIG_AsVal_int(obj1, &val2);
46129 if (!SWIG_IsOK(ecode2)) {
46130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46131 }
46132 arg2 = static_cast< int >(val2);
46133 ecode3 = SWIG_AsVal_int(obj2, &val3);
46134 if (!SWIG_IsOK(ecode3)) {
46135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46136 }
46137 arg3 = static_cast< int >(val3);
46138 {
46139 PyThreadState* __tstate = wxPyBeginAllowThreads();
46140 (arg1)->SetInitSize(arg2,arg3);
46141 wxPyEndAllowThreads(__tstate);
46142 if (PyErr_Occurred()) SWIG_fail;
46143 }
46144 resultobj = SWIG_Py_Void();
46145 return resultobj;
46146 fail:
46147 return NULL;
46148 }
46149
46150
46151 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46152 PyObject *resultobj = 0;
46153 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46154 int arg2 ;
46155 int arg3 ;
46156 void *argp1 = 0 ;
46157 int res1 = 0 ;
46158 int val2 ;
46159 int ecode2 = 0 ;
46160 int val3 ;
46161 int ecode3 = 0 ;
46162 PyObject * obj0 = 0 ;
46163 PyObject * obj1 = 0 ;
46164 PyObject * obj2 = 0 ;
46165 char * kwnames[] = {
46166 (char *) "self",(char *) "width",(char *) "height", NULL
46167 };
46168
46169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46171 if (!SWIG_IsOK(res1)) {
46172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46173 }
46174 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46175 ecode2 = SWIG_AsVal_int(obj1, &val2);
46176 if (!SWIG_IsOK(ecode2)) {
46177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46178 }
46179 arg2 = static_cast< int >(val2);
46180 ecode3 = SWIG_AsVal_int(obj2, &val3);
46181 if (!SWIG_IsOK(ecode3)) {
46182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46183 }
46184 arg3 = static_cast< int >(val3);
46185 {
46186 PyThreadState* __tstate = wxPyBeginAllowThreads();
46187 (arg1)->SetRatio(arg2,arg3);
46188 wxPyEndAllowThreads(__tstate);
46189 if (PyErr_Occurred()) SWIG_fail;
46190 }
46191 resultobj = SWIG_Py_Void();
46192 return resultobj;
46193 fail:
46194 return NULL;
46195 }
46196
46197
46198 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46199 PyObject *resultobj = 0;
46200 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46201 wxSize *arg2 = 0 ;
46202 void *argp1 = 0 ;
46203 int res1 = 0 ;
46204 wxSize temp2 ;
46205 PyObject * obj0 = 0 ;
46206 PyObject * obj1 = 0 ;
46207 char * kwnames[] = {
46208 (char *) "self",(char *) "size", NULL
46209 };
46210
46211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46213 if (!SWIG_IsOK(res1)) {
46214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46215 }
46216 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46217 {
46218 arg2 = &temp2;
46219 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46220 }
46221 {
46222 PyThreadState* __tstate = wxPyBeginAllowThreads();
46223 (arg1)->SetRatio((wxSize const &)*arg2);
46224 wxPyEndAllowThreads(__tstate);
46225 if (PyErr_Occurred()) SWIG_fail;
46226 }
46227 resultobj = SWIG_Py_Void();
46228 return resultobj;
46229 fail:
46230 return NULL;
46231 }
46232
46233
46234 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46235 PyObject *resultobj = 0;
46236 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46237 float arg2 ;
46238 void *argp1 = 0 ;
46239 int res1 = 0 ;
46240 float val2 ;
46241 int ecode2 = 0 ;
46242 PyObject * obj0 = 0 ;
46243 PyObject * obj1 = 0 ;
46244 char * kwnames[] = {
46245 (char *) "self",(char *) "ratio", NULL
46246 };
46247
46248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46250 if (!SWIG_IsOK(res1)) {
46251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46252 }
46253 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46254 ecode2 = SWIG_AsVal_float(obj1, &val2);
46255 if (!SWIG_IsOK(ecode2)) {
46256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46257 }
46258 arg2 = static_cast< float >(val2);
46259 {
46260 PyThreadState* __tstate = wxPyBeginAllowThreads();
46261 (arg1)->SetRatio(arg2);
46262 wxPyEndAllowThreads(__tstate);
46263 if (PyErr_Occurred()) SWIG_fail;
46264 }
46265 resultobj = SWIG_Py_Void();
46266 return resultobj;
46267 fail:
46268 return NULL;
46269 }
46270
46271
46272 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46273 PyObject *resultobj = 0;
46274 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46275 float result;
46276 void *argp1 = 0 ;
46277 int res1 = 0 ;
46278 PyObject *swig_obj[1] ;
46279
46280 if (!args) SWIG_fail;
46281 swig_obj[0] = args;
46282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46283 if (!SWIG_IsOK(res1)) {
46284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46285 }
46286 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46287 {
46288 PyThreadState* __tstate = wxPyBeginAllowThreads();
46289 result = (float)(arg1)->GetRatio();
46290 wxPyEndAllowThreads(__tstate);
46291 if (PyErr_Occurred()) SWIG_fail;
46292 }
46293 resultobj = SWIG_From_float(static_cast< float >(result));
46294 return resultobj;
46295 fail:
46296 return NULL;
46297 }
46298
46299
46300 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46301 PyObject *resultobj = 0;
46302 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46303 wxRect result;
46304 void *argp1 = 0 ;
46305 int res1 = 0 ;
46306 PyObject *swig_obj[1] ;
46307
46308 if (!args) SWIG_fail;
46309 swig_obj[0] = args;
46310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46311 if (!SWIG_IsOK(res1)) {
46312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46313 }
46314 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46315 {
46316 PyThreadState* __tstate = wxPyBeginAllowThreads();
46317 result = (arg1)->GetRect();
46318 wxPyEndAllowThreads(__tstate);
46319 if (PyErr_Occurred()) SWIG_fail;
46320 }
46321 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46322 return resultobj;
46323 fail:
46324 return NULL;
46325 }
46326
46327
46328 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46329 PyObject *resultobj = 0;
46330 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46331 bool result;
46332 void *argp1 = 0 ;
46333 int res1 = 0 ;
46334 PyObject *swig_obj[1] ;
46335
46336 if (!args) SWIG_fail;
46337 swig_obj[0] = args;
46338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46339 if (!SWIG_IsOK(res1)) {
46340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46341 }
46342 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46343 {
46344 PyThreadState* __tstate = wxPyBeginAllowThreads();
46345 result = (bool)(arg1)->IsWindow();
46346 wxPyEndAllowThreads(__tstate);
46347 if (PyErr_Occurred()) SWIG_fail;
46348 }
46349 {
46350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46351 }
46352 return resultobj;
46353 fail:
46354 return NULL;
46355 }
46356
46357
46358 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46359 PyObject *resultobj = 0;
46360 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46361 bool result;
46362 void *argp1 = 0 ;
46363 int res1 = 0 ;
46364 PyObject *swig_obj[1] ;
46365
46366 if (!args) SWIG_fail;
46367 swig_obj[0] = args;
46368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46369 if (!SWIG_IsOK(res1)) {
46370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46371 }
46372 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46373 {
46374 PyThreadState* __tstate = wxPyBeginAllowThreads();
46375 result = (bool)(arg1)->IsSizer();
46376 wxPyEndAllowThreads(__tstate);
46377 if (PyErr_Occurred()) SWIG_fail;
46378 }
46379 {
46380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46381 }
46382 return resultobj;
46383 fail:
46384 return NULL;
46385 }
46386
46387
46388 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46389 PyObject *resultobj = 0;
46390 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46391 bool result;
46392 void *argp1 = 0 ;
46393 int res1 = 0 ;
46394 PyObject *swig_obj[1] ;
46395
46396 if (!args) SWIG_fail;
46397 swig_obj[0] = args;
46398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46399 if (!SWIG_IsOK(res1)) {
46400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46401 }
46402 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46403 {
46404 PyThreadState* __tstate = wxPyBeginAllowThreads();
46405 result = (bool)(arg1)->IsSpacer();
46406 wxPyEndAllowThreads(__tstate);
46407 if (PyErr_Occurred()) SWIG_fail;
46408 }
46409 {
46410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46411 }
46412 return resultobj;
46413 fail:
46414 return NULL;
46415 }
46416
46417
46418 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46419 PyObject *resultobj = 0;
46420 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46421 int arg2 ;
46422 void *argp1 = 0 ;
46423 int res1 = 0 ;
46424 int val2 ;
46425 int ecode2 = 0 ;
46426 PyObject * obj0 = 0 ;
46427 PyObject * obj1 = 0 ;
46428 char * kwnames[] = {
46429 (char *) "self",(char *) "proportion", NULL
46430 };
46431
46432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46434 if (!SWIG_IsOK(res1)) {
46435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46436 }
46437 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46438 ecode2 = SWIG_AsVal_int(obj1, &val2);
46439 if (!SWIG_IsOK(ecode2)) {
46440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46441 }
46442 arg2 = static_cast< int >(val2);
46443 {
46444 PyThreadState* __tstate = wxPyBeginAllowThreads();
46445 (arg1)->SetProportion(arg2);
46446 wxPyEndAllowThreads(__tstate);
46447 if (PyErr_Occurred()) SWIG_fail;
46448 }
46449 resultobj = SWIG_Py_Void();
46450 return resultobj;
46451 fail:
46452 return NULL;
46453 }
46454
46455
46456 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46457 PyObject *resultobj = 0;
46458 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46459 int result;
46460 void *argp1 = 0 ;
46461 int res1 = 0 ;
46462 PyObject *swig_obj[1] ;
46463
46464 if (!args) SWIG_fail;
46465 swig_obj[0] = args;
46466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46467 if (!SWIG_IsOK(res1)) {
46468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46469 }
46470 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46471 {
46472 PyThreadState* __tstate = wxPyBeginAllowThreads();
46473 result = (int)(arg1)->GetProportion();
46474 wxPyEndAllowThreads(__tstate);
46475 if (PyErr_Occurred()) SWIG_fail;
46476 }
46477 resultobj = SWIG_From_int(static_cast< int >(result));
46478 return resultobj;
46479 fail:
46480 return NULL;
46481 }
46482
46483
46484 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46485 PyObject *resultobj = 0;
46486 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46487 int arg2 ;
46488 void *argp1 = 0 ;
46489 int res1 = 0 ;
46490 int val2 ;
46491 int ecode2 = 0 ;
46492 PyObject * obj0 = 0 ;
46493 PyObject * obj1 = 0 ;
46494 char * kwnames[] = {
46495 (char *) "self",(char *) "flag", NULL
46496 };
46497
46498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46500 if (!SWIG_IsOK(res1)) {
46501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46502 }
46503 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46504 ecode2 = SWIG_AsVal_int(obj1, &val2);
46505 if (!SWIG_IsOK(ecode2)) {
46506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46507 }
46508 arg2 = static_cast< int >(val2);
46509 {
46510 PyThreadState* __tstate = wxPyBeginAllowThreads();
46511 (arg1)->SetFlag(arg2);
46512 wxPyEndAllowThreads(__tstate);
46513 if (PyErr_Occurred()) SWIG_fail;
46514 }
46515 resultobj = SWIG_Py_Void();
46516 return resultobj;
46517 fail:
46518 return NULL;
46519 }
46520
46521
46522 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46523 PyObject *resultobj = 0;
46524 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46525 int result;
46526 void *argp1 = 0 ;
46527 int res1 = 0 ;
46528 PyObject *swig_obj[1] ;
46529
46530 if (!args) SWIG_fail;
46531 swig_obj[0] = args;
46532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46533 if (!SWIG_IsOK(res1)) {
46534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46535 }
46536 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46537 {
46538 PyThreadState* __tstate = wxPyBeginAllowThreads();
46539 result = (int)(arg1)->GetFlag();
46540 wxPyEndAllowThreads(__tstate);
46541 if (PyErr_Occurred()) SWIG_fail;
46542 }
46543 resultobj = SWIG_From_int(static_cast< int >(result));
46544 return resultobj;
46545 fail:
46546 return NULL;
46547 }
46548
46549
46550 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46551 PyObject *resultobj = 0;
46552 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46553 int arg2 ;
46554 void *argp1 = 0 ;
46555 int res1 = 0 ;
46556 int val2 ;
46557 int ecode2 = 0 ;
46558 PyObject * obj0 = 0 ;
46559 PyObject * obj1 = 0 ;
46560 char * kwnames[] = {
46561 (char *) "self",(char *) "border", NULL
46562 };
46563
46564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46566 if (!SWIG_IsOK(res1)) {
46567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46568 }
46569 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46570 ecode2 = SWIG_AsVal_int(obj1, &val2);
46571 if (!SWIG_IsOK(ecode2)) {
46572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46573 }
46574 arg2 = static_cast< int >(val2);
46575 {
46576 PyThreadState* __tstate = wxPyBeginAllowThreads();
46577 (arg1)->SetBorder(arg2);
46578 wxPyEndAllowThreads(__tstate);
46579 if (PyErr_Occurred()) SWIG_fail;
46580 }
46581 resultobj = SWIG_Py_Void();
46582 return resultobj;
46583 fail:
46584 return NULL;
46585 }
46586
46587
46588 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46589 PyObject *resultobj = 0;
46590 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46591 int result;
46592 void *argp1 = 0 ;
46593 int res1 = 0 ;
46594 PyObject *swig_obj[1] ;
46595
46596 if (!args) SWIG_fail;
46597 swig_obj[0] = args;
46598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46599 if (!SWIG_IsOK(res1)) {
46600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46601 }
46602 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46603 {
46604 PyThreadState* __tstate = wxPyBeginAllowThreads();
46605 result = (int)(arg1)->GetBorder();
46606 wxPyEndAllowThreads(__tstate);
46607 if (PyErr_Occurred()) SWIG_fail;
46608 }
46609 resultobj = SWIG_From_int(static_cast< int >(result));
46610 return resultobj;
46611 fail:
46612 return NULL;
46613 }
46614
46615
46616 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46617 PyObject *resultobj = 0;
46618 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46619 wxWindow *result = 0 ;
46620 void *argp1 = 0 ;
46621 int res1 = 0 ;
46622 PyObject *swig_obj[1] ;
46623
46624 if (!args) SWIG_fail;
46625 swig_obj[0] = args;
46626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46627 if (!SWIG_IsOK(res1)) {
46628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46629 }
46630 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46631 {
46632 PyThreadState* __tstate = wxPyBeginAllowThreads();
46633 result = (wxWindow *)(arg1)->GetWindow();
46634 wxPyEndAllowThreads(__tstate);
46635 if (PyErr_Occurred()) SWIG_fail;
46636 }
46637 {
46638 resultobj = wxPyMake_wxObject(result, 0);
46639 }
46640 return resultobj;
46641 fail:
46642 return NULL;
46643 }
46644
46645
46646 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46647 PyObject *resultobj = 0;
46648 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46649 wxWindow *arg2 = (wxWindow *) 0 ;
46650 void *argp1 = 0 ;
46651 int res1 = 0 ;
46652 void *argp2 = 0 ;
46653 int res2 = 0 ;
46654 PyObject * obj0 = 0 ;
46655 PyObject * obj1 = 0 ;
46656 char * kwnames[] = {
46657 (char *) "self",(char *) "window", NULL
46658 };
46659
46660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46662 if (!SWIG_IsOK(res1)) {
46663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46664 }
46665 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46667 if (!SWIG_IsOK(res2)) {
46668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46669 }
46670 arg2 = reinterpret_cast< wxWindow * >(argp2);
46671 {
46672 PyThreadState* __tstate = wxPyBeginAllowThreads();
46673 (arg1)->SetWindow(arg2);
46674 wxPyEndAllowThreads(__tstate);
46675 if (PyErr_Occurred()) SWIG_fail;
46676 }
46677 resultobj = SWIG_Py_Void();
46678 return resultobj;
46679 fail:
46680 return NULL;
46681 }
46682
46683
46684 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46685 PyObject *resultobj = 0;
46686 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46687 wxSizer *result = 0 ;
46688 void *argp1 = 0 ;
46689 int res1 = 0 ;
46690 PyObject *swig_obj[1] ;
46691
46692 if (!args) SWIG_fail;
46693 swig_obj[0] = args;
46694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46695 if (!SWIG_IsOK(res1)) {
46696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46697 }
46698 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46699 {
46700 PyThreadState* __tstate = wxPyBeginAllowThreads();
46701 result = (wxSizer *)(arg1)->GetSizer();
46702 wxPyEndAllowThreads(__tstate);
46703 if (PyErr_Occurred()) SWIG_fail;
46704 }
46705 {
46706 resultobj = wxPyMake_wxObject(result, (bool)0);
46707 }
46708 return resultobj;
46709 fail:
46710 return NULL;
46711 }
46712
46713
46714 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46715 PyObject *resultobj = 0;
46716 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46717 wxSizer *arg2 = (wxSizer *) 0 ;
46718 void *argp1 = 0 ;
46719 int res1 = 0 ;
46720 int res2 = 0 ;
46721 PyObject * obj0 = 0 ;
46722 PyObject * obj1 = 0 ;
46723 char * kwnames[] = {
46724 (char *) "self",(char *) "sizer", NULL
46725 };
46726
46727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46729 if (!SWIG_IsOK(res1)) {
46730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46731 }
46732 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46733 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46734 if (!SWIG_IsOK(res2)) {
46735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46736 }
46737 {
46738 PyThreadState* __tstate = wxPyBeginAllowThreads();
46739 (arg1)->SetSizer(arg2);
46740 wxPyEndAllowThreads(__tstate);
46741 if (PyErr_Occurred()) SWIG_fail;
46742 }
46743 resultobj = SWIG_Py_Void();
46744 return resultobj;
46745 fail:
46746 return NULL;
46747 }
46748
46749
46750 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46751 PyObject *resultobj = 0;
46752 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46753 wxSize *result = 0 ;
46754 void *argp1 = 0 ;
46755 int res1 = 0 ;
46756 PyObject *swig_obj[1] ;
46757
46758 if (!args) SWIG_fail;
46759 swig_obj[0] = args;
46760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46761 if (!SWIG_IsOK(res1)) {
46762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46763 }
46764 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46765 {
46766 PyThreadState* __tstate = wxPyBeginAllowThreads();
46767 {
46768 wxSize const &_result_ref = (arg1)->GetSpacer();
46769 result = (wxSize *) &_result_ref;
46770 }
46771 wxPyEndAllowThreads(__tstate);
46772 if (PyErr_Occurred()) SWIG_fail;
46773 }
46774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46775 return resultobj;
46776 fail:
46777 return NULL;
46778 }
46779
46780
46781 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46782 PyObject *resultobj = 0;
46783 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46784 wxSize *arg2 = 0 ;
46785 void *argp1 = 0 ;
46786 int res1 = 0 ;
46787 wxSize temp2 ;
46788 PyObject * obj0 = 0 ;
46789 PyObject * obj1 = 0 ;
46790 char * kwnames[] = {
46791 (char *) "self",(char *) "size", NULL
46792 };
46793
46794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46796 if (!SWIG_IsOK(res1)) {
46797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46798 }
46799 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46800 {
46801 arg2 = &temp2;
46802 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46803 }
46804 {
46805 PyThreadState* __tstate = wxPyBeginAllowThreads();
46806 (arg1)->SetSpacer((wxSize const &)*arg2);
46807 wxPyEndAllowThreads(__tstate);
46808 if (PyErr_Occurred()) SWIG_fail;
46809 }
46810 resultobj = SWIG_Py_Void();
46811 return resultobj;
46812 fail:
46813 return NULL;
46814 }
46815
46816
46817 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46818 PyObject *resultobj = 0;
46819 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46820 bool arg2 ;
46821 void *argp1 = 0 ;
46822 int res1 = 0 ;
46823 bool val2 ;
46824 int ecode2 = 0 ;
46825 PyObject * obj0 = 0 ;
46826 PyObject * obj1 = 0 ;
46827 char * kwnames[] = {
46828 (char *) "self",(char *) "show", NULL
46829 };
46830
46831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46833 if (!SWIG_IsOK(res1)) {
46834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46835 }
46836 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46837 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46838 if (!SWIG_IsOK(ecode2)) {
46839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46840 }
46841 arg2 = static_cast< bool >(val2);
46842 {
46843 PyThreadState* __tstate = wxPyBeginAllowThreads();
46844 (arg1)->Show(arg2);
46845 wxPyEndAllowThreads(__tstate);
46846 if (PyErr_Occurred()) SWIG_fail;
46847 }
46848 resultobj = SWIG_Py_Void();
46849 return resultobj;
46850 fail:
46851 return NULL;
46852 }
46853
46854
46855 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46856 PyObject *resultobj = 0;
46857 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46858 bool result;
46859 void *argp1 = 0 ;
46860 int res1 = 0 ;
46861 PyObject *swig_obj[1] ;
46862
46863 if (!args) SWIG_fail;
46864 swig_obj[0] = args;
46865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46866 if (!SWIG_IsOK(res1)) {
46867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46868 }
46869 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46870 {
46871 PyThreadState* __tstate = wxPyBeginAllowThreads();
46872 result = (bool)(arg1)->IsShown();
46873 wxPyEndAllowThreads(__tstate);
46874 if (PyErr_Occurred()) SWIG_fail;
46875 }
46876 {
46877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46878 }
46879 return resultobj;
46880 fail:
46881 return NULL;
46882 }
46883
46884
46885 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46886 PyObject *resultobj = 0;
46887 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46888 wxPoint result;
46889 void *argp1 = 0 ;
46890 int res1 = 0 ;
46891 PyObject *swig_obj[1] ;
46892
46893 if (!args) SWIG_fail;
46894 swig_obj[0] = args;
46895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46896 if (!SWIG_IsOK(res1)) {
46897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46898 }
46899 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46900 {
46901 PyThreadState* __tstate = wxPyBeginAllowThreads();
46902 result = (arg1)->GetPosition();
46903 wxPyEndAllowThreads(__tstate);
46904 if (PyErr_Occurred()) SWIG_fail;
46905 }
46906 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46907 return resultobj;
46908 fail:
46909 return NULL;
46910 }
46911
46912
46913 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46914 PyObject *resultobj = 0;
46915 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46916 PyObject *result = 0 ;
46917 void *argp1 = 0 ;
46918 int res1 = 0 ;
46919 PyObject *swig_obj[1] ;
46920
46921 if (!args) SWIG_fail;
46922 swig_obj[0] = args;
46923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46924 if (!SWIG_IsOK(res1)) {
46925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46926 }
46927 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46928 {
46929 PyThreadState* __tstate = wxPyBeginAllowThreads();
46930 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46931 wxPyEndAllowThreads(__tstate);
46932 if (PyErr_Occurred()) SWIG_fail;
46933 }
46934 resultobj = result;
46935 return resultobj;
46936 fail:
46937 return NULL;
46938 }
46939
46940
46941 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46942 PyObject *resultobj = 0;
46943 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46944 PyObject *arg2 = (PyObject *) 0 ;
46945 void *argp1 = 0 ;
46946 int res1 = 0 ;
46947 PyObject * obj0 = 0 ;
46948 PyObject * obj1 = 0 ;
46949 char * kwnames[] = {
46950 (char *) "self",(char *) "userData", NULL
46951 };
46952
46953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46955 if (!SWIG_IsOK(res1)) {
46956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46957 }
46958 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46959 arg2 = obj1;
46960 {
46961 PyThreadState* __tstate = wxPyBeginAllowThreads();
46962 wxSizerItem_SetUserData(arg1,arg2);
46963 wxPyEndAllowThreads(__tstate);
46964 if (PyErr_Occurred()) SWIG_fail;
46965 }
46966 resultobj = SWIG_Py_Void();
46967 return resultobj;
46968 fail:
46969 return NULL;
46970 }
46971
46972
46973 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46974 PyObject *obj;
46975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46976 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46977 return SWIG_Py_Void();
46978 }
46979
46980 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46981 return SWIG_Python_InitShadowInstance(args);
46982 }
46983
46984 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46985 PyObject *resultobj = 0;
46986 wxSizer *arg1 = (wxSizer *) 0 ;
46987 void *argp1 = 0 ;
46988 int res1 = 0 ;
46989 PyObject *swig_obj[1] ;
46990
46991 if (!args) SWIG_fail;
46992 swig_obj[0] = args;
46993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46994 if (!SWIG_IsOK(res1)) {
46995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46996 }
46997 arg1 = reinterpret_cast< wxSizer * >(argp1);
46998 {
46999 PyThreadState* __tstate = wxPyBeginAllowThreads();
47000 delete arg1;
47001
47002 wxPyEndAllowThreads(__tstate);
47003 if (PyErr_Occurred()) SWIG_fail;
47004 }
47005 resultobj = SWIG_Py_Void();
47006 return resultobj;
47007 fail:
47008 return NULL;
47009 }
47010
47011
47012 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47013 PyObject *resultobj = 0;
47014 wxSizer *arg1 = (wxSizer *) 0 ;
47015 PyObject *arg2 = (PyObject *) 0 ;
47016 void *argp1 = 0 ;
47017 int res1 = 0 ;
47018 PyObject * obj0 = 0 ;
47019 PyObject * obj1 = 0 ;
47020 char * kwnames[] = {
47021 (char *) "self",(char *) "_self", NULL
47022 };
47023
47024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47026 if (!SWIG_IsOK(res1)) {
47027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47028 }
47029 arg1 = reinterpret_cast< wxSizer * >(argp1);
47030 arg2 = obj1;
47031 {
47032 PyThreadState* __tstate = wxPyBeginAllowThreads();
47033 wxSizer__setOORInfo(arg1,arg2);
47034 wxPyEndAllowThreads(__tstate);
47035 if (PyErr_Occurred()) SWIG_fail;
47036 }
47037 resultobj = SWIG_Py_Void();
47038 return resultobj;
47039 fail:
47040 return NULL;
47041 }
47042
47043
47044 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47045 PyObject *resultobj = 0;
47046 wxSizer *arg1 = (wxSizer *) 0 ;
47047 PyObject *arg2 = (PyObject *) 0 ;
47048 int arg3 = (int) 0 ;
47049 int arg4 = (int) 0 ;
47050 int arg5 = (int) 0 ;
47051 PyObject *arg6 = (PyObject *) NULL ;
47052 wxSizerItem *result = 0 ;
47053 void *argp1 = 0 ;
47054 int res1 = 0 ;
47055 int val3 ;
47056 int ecode3 = 0 ;
47057 int val4 ;
47058 int ecode4 = 0 ;
47059 int val5 ;
47060 int ecode5 = 0 ;
47061 PyObject * obj0 = 0 ;
47062 PyObject * obj1 = 0 ;
47063 PyObject * obj2 = 0 ;
47064 PyObject * obj3 = 0 ;
47065 PyObject * obj4 = 0 ;
47066 PyObject * obj5 = 0 ;
47067 char * kwnames[] = {
47068 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47069 };
47070
47071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47073 if (!SWIG_IsOK(res1)) {
47074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47075 }
47076 arg1 = reinterpret_cast< wxSizer * >(argp1);
47077 arg2 = obj1;
47078 if (obj2) {
47079 ecode3 = SWIG_AsVal_int(obj2, &val3);
47080 if (!SWIG_IsOK(ecode3)) {
47081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47082 }
47083 arg3 = static_cast< int >(val3);
47084 }
47085 if (obj3) {
47086 ecode4 = SWIG_AsVal_int(obj3, &val4);
47087 if (!SWIG_IsOK(ecode4)) {
47088 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47089 }
47090 arg4 = static_cast< int >(val4);
47091 }
47092 if (obj4) {
47093 ecode5 = SWIG_AsVal_int(obj4, &val5);
47094 if (!SWIG_IsOK(ecode5)) {
47095 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47096 }
47097 arg5 = static_cast< int >(val5);
47098 }
47099 if (obj5) {
47100 arg6 = obj5;
47101 }
47102 {
47103 PyThreadState* __tstate = wxPyBeginAllowThreads();
47104 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47105 wxPyEndAllowThreads(__tstate);
47106 if (PyErr_Occurred()) SWIG_fail;
47107 }
47108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47109 return resultobj;
47110 fail:
47111 return NULL;
47112 }
47113
47114
47115 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47116 PyObject *resultobj = 0;
47117 wxSizer *arg1 = (wxSizer *) 0 ;
47118 int arg2 ;
47119 PyObject *arg3 = (PyObject *) 0 ;
47120 int arg4 = (int) 0 ;
47121 int arg5 = (int) 0 ;
47122 int arg6 = (int) 0 ;
47123 PyObject *arg7 = (PyObject *) NULL ;
47124 wxSizerItem *result = 0 ;
47125 void *argp1 = 0 ;
47126 int res1 = 0 ;
47127 int val2 ;
47128 int ecode2 = 0 ;
47129 int val4 ;
47130 int ecode4 = 0 ;
47131 int val5 ;
47132 int ecode5 = 0 ;
47133 int val6 ;
47134 int ecode6 = 0 ;
47135 PyObject * obj0 = 0 ;
47136 PyObject * obj1 = 0 ;
47137 PyObject * obj2 = 0 ;
47138 PyObject * obj3 = 0 ;
47139 PyObject * obj4 = 0 ;
47140 PyObject * obj5 = 0 ;
47141 PyObject * obj6 = 0 ;
47142 char * kwnames[] = {
47143 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47144 };
47145
47146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47148 if (!SWIG_IsOK(res1)) {
47149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47150 }
47151 arg1 = reinterpret_cast< wxSizer * >(argp1);
47152 ecode2 = SWIG_AsVal_int(obj1, &val2);
47153 if (!SWIG_IsOK(ecode2)) {
47154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47155 }
47156 arg2 = static_cast< int >(val2);
47157 arg3 = obj2;
47158 if (obj3) {
47159 ecode4 = SWIG_AsVal_int(obj3, &val4);
47160 if (!SWIG_IsOK(ecode4)) {
47161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47162 }
47163 arg4 = static_cast< int >(val4);
47164 }
47165 if (obj4) {
47166 ecode5 = SWIG_AsVal_int(obj4, &val5);
47167 if (!SWIG_IsOK(ecode5)) {
47168 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47169 }
47170 arg5 = static_cast< int >(val5);
47171 }
47172 if (obj5) {
47173 ecode6 = SWIG_AsVal_int(obj5, &val6);
47174 if (!SWIG_IsOK(ecode6)) {
47175 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47176 }
47177 arg6 = static_cast< int >(val6);
47178 }
47179 if (obj6) {
47180 arg7 = obj6;
47181 }
47182 {
47183 PyThreadState* __tstate = wxPyBeginAllowThreads();
47184 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47185 wxPyEndAllowThreads(__tstate);
47186 if (PyErr_Occurred()) SWIG_fail;
47187 }
47188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47189 return resultobj;
47190 fail:
47191 return NULL;
47192 }
47193
47194
47195 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47196 PyObject *resultobj = 0;
47197 wxSizer *arg1 = (wxSizer *) 0 ;
47198 PyObject *arg2 = (PyObject *) 0 ;
47199 int arg3 = (int) 0 ;
47200 int arg4 = (int) 0 ;
47201 int arg5 = (int) 0 ;
47202 PyObject *arg6 = (PyObject *) NULL ;
47203 wxSizerItem *result = 0 ;
47204 void *argp1 = 0 ;
47205 int res1 = 0 ;
47206 int val3 ;
47207 int ecode3 = 0 ;
47208 int val4 ;
47209 int ecode4 = 0 ;
47210 int val5 ;
47211 int ecode5 = 0 ;
47212 PyObject * obj0 = 0 ;
47213 PyObject * obj1 = 0 ;
47214 PyObject * obj2 = 0 ;
47215 PyObject * obj3 = 0 ;
47216 PyObject * obj4 = 0 ;
47217 PyObject * obj5 = 0 ;
47218 char * kwnames[] = {
47219 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47220 };
47221
47222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47224 if (!SWIG_IsOK(res1)) {
47225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47226 }
47227 arg1 = reinterpret_cast< wxSizer * >(argp1);
47228 arg2 = obj1;
47229 if (obj2) {
47230 ecode3 = SWIG_AsVal_int(obj2, &val3);
47231 if (!SWIG_IsOK(ecode3)) {
47232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47233 }
47234 arg3 = static_cast< int >(val3);
47235 }
47236 if (obj3) {
47237 ecode4 = SWIG_AsVal_int(obj3, &val4);
47238 if (!SWIG_IsOK(ecode4)) {
47239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47240 }
47241 arg4 = static_cast< int >(val4);
47242 }
47243 if (obj4) {
47244 ecode5 = SWIG_AsVal_int(obj4, &val5);
47245 if (!SWIG_IsOK(ecode5)) {
47246 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47247 }
47248 arg5 = static_cast< int >(val5);
47249 }
47250 if (obj5) {
47251 arg6 = obj5;
47252 }
47253 {
47254 PyThreadState* __tstate = wxPyBeginAllowThreads();
47255 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47256 wxPyEndAllowThreads(__tstate);
47257 if (PyErr_Occurred()) SWIG_fail;
47258 }
47259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47260 return resultobj;
47261 fail:
47262 return NULL;
47263 }
47264
47265
47266 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47267 PyObject *resultobj = 0;
47268 wxSizer *arg1 = (wxSizer *) 0 ;
47269 PyObject *arg2 = (PyObject *) 0 ;
47270 bool result;
47271 void *argp1 = 0 ;
47272 int res1 = 0 ;
47273 PyObject * obj0 = 0 ;
47274 PyObject * obj1 = 0 ;
47275 char * kwnames[] = {
47276 (char *) "self",(char *) "item", NULL
47277 };
47278
47279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47281 if (!SWIG_IsOK(res1)) {
47282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47283 }
47284 arg1 = reinterpret_cast< wxSizer * >(argp1);
47285 arg2 = obj1;
47286 {
47287 PyThreadState* __tstate = wxPyBeginAllowThreads();
47288 result = (bool)wxSizer_Remove(arg1,arg2);
47289 wxPyEndAllowThreads(__tstate);
47290 if (PyErr_Occurred()) SWIG_fail;
47291 }
47292 {
47293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47294 }
47295 return resultobj;
47296 fail:
47297 return NULL;
47298 }
47299
47300
47301 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47302 PyObject *resultobj = 0;
47303 wxSizer *arg1 = (wxSizer *) 0 ;
47304 PyObject *arg2 = (PyObject *) 0 ;
47305 bool result;
47306 void *argp1 = 0 ;
47307 int res1 = 0 ;
47308 PyObject * obj0 = 0 ;
47309 PyObject * obj1 = 0 ;
47310 char * kwnames[] = {
47311 (char *) "self",(char *) "item", NULL
47312 };
47313
47314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47316 if (!SWIG_IsOK(res1)) {
47317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47318 }
47319 arg1 = reinterpret_cast< wxSizer * >(argp1);
47320 arg2 = obj1;
47321 {
47322 PyThreadState* __tstate = wxPyBeginAllowThreads();
47323 result = (bool)wxSizer_Detach(arg1,arg2);
47324 wxPyEndAllowThreads(__tstate);
47325 if (PyErr_Occurred()) SWIG_fail;
47326 }
47327 {
47328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47329 }
47330 return resultobj;
47331 fail:
47332 return NULL;
47333 }
47334
47335
47336 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47337 PyObject *resultobj = 0;
47338 wxSizer *arg1 = (wxSizer *) 0 ;
47339 PyObject *arg2 = (PyObject *) 0 ;
47340 wxSizerItem *result = 0 ;
47341 void *argp1 = 0 ;
47342 int res1 = 0 ;
47343 PyObject * obj0 = 0 ;
47344 PyObject * obj1 = 0 ;
47345 char * kwnames[] = {
47346 (char *) "self",(char *) "item", NULL
47347 };
47348
47349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47351 if (!SWIG_IsOK(res1)) {
47352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47353 }
47354 arg1 = reinterpret_cast< wxSizer * >(argp1);
47355 arg2 = obj1;
47356 {
47357 PyThreadState* __tstate = wxPyBeginAllowThreads();
47358 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47359 wxPyEndAllowThreads(__tstate);
47360 if (PyErr_Occurred()) SWIG_fail;
47361 }
47362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47363 return resultobj;
47364 fail:
47365 return NULL;
47366 }
47367
47368
47369 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47370 PyObject *resultobj = 0;
47371 wxSizer *arg1 = (wxSizer *) 0 ;
47372 PyObject *arg2 = (PyObject *) 0 ;
47373 wxSize *arg3 = 0 ;
47374 void *argp1 = 0 ;
47375 int res1 = 0 ;
47376 wxSize temp3 ;
47377 PyObject * obj0 = 0 ;
47378 PyObject * obj1 = 0 ;
47379 PyObject * obj2 = 0 ;
47380 char * kwnames[] = {
47381 (char *) "self",(char *) "item",(char *) "size", NULL
47382 };
47383
47384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47386 if (!SWIG_IsOK(res1)) {
47387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47388 }
47389 arg1 = reinterpret_cast< wxSizer * >(argp1);
47390 arg2 = obj1;
47391 {
47392 arg3 = &temp3;
47393 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47394 }
47395 {
47396 PyThreadState* __tstate = wxPyBeginAllowThreads();
47397 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47398 wxPyEndAllowThreads(__tstate);
47399 if (PyErr_Occurred()) SWIG_fail;
47400 }
47401 resultobj = SWIG_Py_Void();
47402 return resultobj;
47403 fail:
47404 return NULL;
47405 }
47406
47407
47408 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47409 PyObject *resultobj = 0;
47410 wxSizer *arg1 = (wxSizer *) 0 ;
47411 wxWindow *arg2 = (wxWindow *) 0 ;
47412 wxWindow *arg3 = (wxWindow *) 0 ;
47413 bool arg4 = (bool) false ;
47414 bool result;
47415 void *argp1 = 0 ;
47416 int res1 = 0 ;
47417 void *argp2 = 0 ;
47418 int res2 = 0 ;
47419 void *argp3 = 0 ;
47420 int res3 = 0 ;
47421 bool val4 ;
47422 int ecode4 = 0 ;
47423 PyObject * obj0 = 0 ;
47424 PyObject * obj1 = 0 ;
47425 PyObject * obj2 = 0 ;
47426 PyObject * obj3 = 0 ;
47427 char * kwnames[] = {
47428 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47429 };
47430
47431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47433 if (!SWIG_IsOK(res1)) {
47434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47435 }
47436 arg1 = reinterpret_cast< wxSizer * >(argp1);
47437 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47438 if (!SWIG_IsOK(res2)) {
47439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47440 }
47441 arg2 = reinterpret_cast< wxWindow * >(argp2);
47442 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47443 if (!SWIG_IsOK(res3)) {
47444 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47445 }
47446 arg3 = reinterpret_cast< wxWindow * >(argp3);
47447 if (obj3) {
47448 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47449 if (!SWIG_IsOK(ecode4)) {
47450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47451 }
47452 arg4 = static_cast< bool >(val4);
47453 }
47454 {
47455 PyThreadState* __tstate = wxPyBeginAllowThreads();
47456 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47457 wxPyEndAllowThreads(__tstate);
47458 if (PyErr_Occurred()) SWIG_fail;
47459 }
47460 {
47461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47462 }
47463 return resultobj;
47464 fail:
47465 return NULL;
47466 }
47467
47468
47469 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47470 PyObject *resultobj = 0;
47471 wxSizer *arg1 = (wxSizer *) 0 ;
47472 wxSizer *arg2 = (wxSizer *) 0 ;
47473 wxSizer *arg3 = (wxSizer *) 0 ;
47474 bool arg4 = (bool) false ;
47475 bool result;
47476 void *argp1 = 0 ;
47477 int res1 = 0 ;
47478 void *argp2 = 0 ;
47479 int res2 = 0 ;
47480 void *argp3 = 0 ;
47481 int res3 = 0 ;
47482 bool val4 ;
47483 int ecode4 = 0 ;
47484 PyObject * obj0 = 0 ;
47485 PyObject * obj1 = 0 ;
47486 PyObject * obj2 = 0 ;
47487 PyObject * obj3 = 0 ;
47488 char * kwnames[] = {
47489 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47490 };
47491
47492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47494 if (!SWIG_IsOK(res1)) {
47495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47496 }
47497 arg1 = reinterpret_cast< wxSizer * >(argp1);
47498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47499 if (!SWIG_IsOK(res2)) {
47500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47501 }
47502 arg2 = reinterpret_cast< wxSizer * >(argp2);
47503 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47504 if (!SWIG_IsOK(res3)) {
47505 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47506 }
47507 arg3 = reinterpret_cast< wxSizer * >(argp3);
47508 if (obj3) {
47509 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47510 if (!SWIG_IsOK(ecode4)) {
47511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47512 }
47513 arg4 = static_cast< bool >(val4);
47514 }
47515 {
47516 PyThreadState* __tstate = wxPyBeginAllowThreads();
47517 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47518 wxPyEndAllowThreads(__tstate);
47519 if (PyErr_Occurred()) SWIG_fail;
47520 }
47521 {
47522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47523 }
47524 return resultobj;
47525 fail:
47526 return NULL;
47527 }
47528
47529
47530 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47531 PyObject *resultobj = 0;
47532 wxSizer *arg1 = (wxSizer *) 0 ;
47533 size_t arg2 ;
47534 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47535 bool result;
47536 void *argp1 = 0 ;
47537 int res1 = 0 ;
47538 size_t val2 ;
47539 int ecode2 = 0 ;
47540 void *argp3 = 0 ;
47541 int res3 = 0 ;
47542 PyObject * obj0 = 0 ;
47543 PyObject * obj1 = 0 ;
47544 PyObject * obj2 = 0 ;
47545 char * kwnames[] = {
47546 (char *) "self",(char *) "index",(char *) "newitem", NULL
47547 };
47548
47549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47551 if (!SWIG_IsOK(res1)) {
47552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47553 }
47554 arg1 = reinterpret_cast< wxSizer * >(argp1);
47555 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47556 if (!SWIG_IsOK(ecode2)) {
47557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47558 }
47559 arg2 = static_cast< size_t >(val2);
47560 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47561 if (!SWIG_IsOK(res3)) {
47562 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47563 }
47564 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47565 {
47566 PyThreadState* __tstate = wxPyBeginAllowThreads();
47567 result = (bool)(arg1)->Replace(arg2,arg3);
47568 wxPyEndAllowThreads(__tstate);
47569 if (PyErr_Occurred()) SWIG_fail;
47570 }
47571 {
47572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47573 }
47574 return resultobj;
47575 fail:
47576 return NULL;
47577 }
47578
47579
47580 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47581 PyObject *resultobj = 0;
47582 wxSizer *arg1 = (wxSizer *) 0 ;
47583 wxWindow *arg2 = (wxWindow *) 0 ;
47584 void *argp1 = 0 ;
47585 int res1 = 0 ;
47586 void *argp2 = 0 ;
47587 int res2 = 0 ;
47588 PyObject * obj0 = 0 ;
47589 PyObject * obj1 = 0 ;
47590 char * kwnames[] = {
47591 (char *) "self",(char *) "window", NULL
47592 };
47593
47594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47596 if (!SWIG_IsOK(res1)) {
47597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47598 }
47599 arg1 = reinterpret_cast< wxSizer * >(argp1);
47600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47601 if (!SWIG_IsOK(res2)) {
47602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47603 }
47604 arg2 = reinterpret_cast< wxWindow * >(argp2);
47605 {
47606 PyThreadState* __tstate = wxPyBeginAllowThreads();
47607 (arg1)->SetContainingWindow(arg2);
47608 wxPyEndAllowThreads(__tstate);
47609 if (PyErr_Occurred()) SWIG_fail;
47610 }
47611 resultobj = SWIG_Py_Void();
47612 return resultobj;
47613 fail:
47614 return NULL;
47615 }
47616
47617
47618 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47619 PyObject *resultobj = 0;
47620 wxSizer *arg1 = (wxSizer *) 0 ;
47621 wxWindow *result = 0 ;
47622 void *argp1 = 0 ;
47623 int res1 = 0 ;
47624 PyObject *swig_obj[1] ;
47625
47626 if (!args) SWIG_fail;
47627 swig_obj[0] = args;
47628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47629 if (!SWIG_IsOK(res1)) {
47630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47631 }
47632 arg1 = reinterpret_cast< wxSizer * >(argp1);
47633 {
47634 PyThreadState* __tstate = wxPyBeginAllowThreads();
47635 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47636 wxPyEndAllowThreads(__tstate);
47637 if (PyErr_Occurred()) SWIG_fail;
47638 }
47639 {
47640 resultobj = wxPyMake_wxObject(result, 0);
47641 }
47642 return resultobj;
47643 fail:
47644 return NULL;
47645 }
47646
47647
47648 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47649 PyObject *resultobj = 0;
47650 wxSizer *arg1 = (wxSizer *) 0 ;
47651 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47652 wxSizerItem *result = 0 ;
47653 void *argp1 = 0 ;
47654 int res1 = 0 ;
47655 int res2 = 0 ;
47656 PyObject * obj0 = 0 ;
47657 PyObject * obj1 = 0 ;
47658 char * kwnames[] = {
47659 (char *) "self",(char *) "item", NULL
47660 };
47661
47662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47664 if (!SWIG_IsOK(res1)) {
47665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47666 }
47667 arg1 = reinterpret_cast< wxSizer * >(argp1);
47668 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47669 if (!SWIG_IsOK(res2)) {
47670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47671 }
47672 {
47673 PyThreadState* __tstate = wxPyBeginAllowThreads();
47674 result = (wxSizerItem *)(arg1)->Add(arg2);
47675 wxPyEndAllowThreads(__tstate);
47676 if (PyErr_Occurred()) SWIG_fail;
47677 }
47678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47679 return resultobj;
47680 fail:
47681 return NULL;
47682 }
47683
47684
47685 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47686 PyObject *resultobj = 0;
47687 wxSizer *arg1 = (wxSizer *) 0 ;
47688 size_t arg2 ;
47689 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47690 wxSizerItem *result = 0 ;
47691 void *argp1 = 0 ;
47692 int res1 = 0 ;
47693 size_t val2 ;
47694 int ecode2 = 0 ;
47695 int res3 = 0 ;
47696 PyObject * obj0 = 0 ;
47697 PyObject * obj1 = 0 ;
47698 PyObject * obj2 = 0 ;
47699 char * kwnames[] = {
47700 (char *) "self",(char *) "index",(char *) "item", NULL
47701 };
47702
47703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47705 if (!SWIG_IsOK(res1)) {
47706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47707 }
47708 arg1 = reinterpret_cast< wxSizer * >(argp1);
47709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47710 if (!SWIG_IsOK(ecode2)) {
47711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47712 }
47713 arg2 = static_cast< size_t >(val2);
47714 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47715 if (!SWIG_IsOK(res3)) {
47716 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47717 }
47718 {
47719 PyThreadState* __tstate = wxPyBeginAllowThreads();
47720 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47721 wxPyEndAllowThreads(__tstate);
47722 if (PyErr_Occurred()) SWIG_fail;
47723 }
47724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47725 return resultobj;
47726 fail:
47727 return NULL;
47728 }
47729
47730
47731 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47732 PyObject *resultobj = 0;
47733 wxSizer *arg1 = (wxSizer *) 0 ;
47734 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47735 wxSizerItem *result = 0 ;
47736 void *argp1 = 0 ;
47737 int res1 = 0 ;
47738 int res2 = 0 ;
47739 PyObject * obj0 = 0 ;
47740 PyObject * obj1 = 0 ;
47741 char * kwnames[] = {
47742 (char *) "self",(char *) "item", NULL
47743 };
47744
47745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47747 if (!SWIG_IsOK(res1)) {
47748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47749 }
47750 arg1 = reinterpret_cast< wxSizer * >(argp1);
47751 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47752 if (!SWIG_IsOK(res2)) {
47753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47754 }
47755 {
47756 PyThreadState* __tstate = wxPyBeginAllowThreads();
47757 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47758 wxPyEndAllowThreads(__tstate);
47759 if (PyErr_Occurred()) SWIG_fail;
47760 }
47761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47762 return resultobj;
47763 fail:
47764 return NULL;
47765 }
47766
47767
47768 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47769 PyObject *resultobj = 0;
47770 wxSizer *arg1 = (wxSizer *) 0 ;
47771 int arg2 ;
47772 int arg3 ;
47773 int arg4 ;
47774 int arg5 ;
47775 void *argp1 = 0 ;
47776 int res1 = 0 ;
47777 int val2 ;
47778 int ecode2 = 0 ;
47779 int val3 ;
47780 int ecode3 = 0 ;
47781 int val4 ;
47782 int ecode4 = 0 ;
47783 int val5 ;
47784 int ecode5 = 0 ;
47785 PyObject * obj0 = 0 ;
47786 PyObject * obj1 = 0 ;
47787 PyObject * obj2 = 0 ;
47788 PyObject * obj3 = 0 ;
47789 PyObject * obj4 = 0 ;
47790 char * kwnames[] = {
47791 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47792 };
47793
47794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47796 if (!SWIG_IsOK(res1)) {
47797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47798 }
47799 arg1 = reinterpret_cast< wxSizer * >(argp1);
47800 ecode2 = SWIG_AsVal_int(obj1, &val2);
47801 if (!SWIG_IsOK(ecode2)) {
47802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47803 }
47804 arg2 = static_cast< int >(val2);
47805 ecode3 = SWIG_AsVal_int(obj2, &val3);
47806 if (!SWIG_IsOK(ecode3)) {
47807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47808 }
47809 arg3 = static_cast< int >(val3);
47810 ecode4 = SWIG_AsVal_int(obj3, &val4);
47811 if (!SWIG_IsOK(ecode4)) {
47812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47813 }
47814 arg4 = static_cast< int >(val4);
47815 ecode5 = SWIG_AsVal_int(obj4, &val5);
47816 if (!SWIG_IsOK(ecode5)) {
47817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47818 }
47819 arg5 = static_cast< int >(val5);
47820 {
47821 PyThreadState* __tstate = wxPyBeginAllowThreads();
47822 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47823 wxPyEndAllowThreads(__tstate);
47824 if (PyErr_Occurred()) SWIG_fail;
47825 }
47826 resultobj = SWIG_Py_Void();
47827 return resultobj;
47828 fail:
47829 return NULL;
47830 }
47831
47832
47833 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47834 PyObject *resultobj = 0;
47835 wxSizer *arg1 = (wxSizer *) 0 ;
47836 wxSize *arg2 = 0 ;
47837 void *argp1 = 0 ;
47838 int res1 = 0 ;
47839 wxSize temp2 ;
47840 PyObject * obj0 = 0 ;
47841 PyObject * obj1 = 0 ;
47842 char * kwnames[] = {
47843 (char *) "self",(char *) "size", NULL
47844 };
47845
47846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47848 if (!SWIG_IsOK(res1)) {
47849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47850 }
47851 arg1 = reinterpret_cast< wxSizer * >(argp1);
47852 {
47853 arg2 = &temp2;
47854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47855 }
47856 {
47857 PyThreadState* __tstate = wxPyBeginAllowThreads();
47858 (arg1)->SetMinSize((wxSize const &)*arg2);
47859 wxPyEndAllowThreads(__tstate);
47860 if (PyErr_Occurred()) SWIG_fail;
47861 }
47862 resultobj = SWIG_Py_Void();
47863 return resultobj;
47864 fail:
47865 return NULL;
47866 }
47867
47868
47869 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47870 PyObject *resultobj = 0;
47871 wxSizer *arg1 = (wxSizer *) 0 ;
47872 wxSize result;
47873 void *argp1 = 0 ;
47874 int res1 = 0 ;
47875 PyObject *swig_obj[1] ;
47876
47877 if (!args) SWIG_fail;
47878 swig_obj[0] = args;
47879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47880 if (!SWIG_IsOK(res1)) {
47881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47882 }
47883 arg1 = reinterpret_cast< wxSizer * >(argp1);
47884 {
47885 PyThreadState* __tstate = wxPyBeginAllowThreads();
47886 result = (arg1)->GetSize();
47887 wxPyEndAllowThreads(__tstate);
47888 if (PyErr_Occurred()) SWIG_fail;
47889 }
47890 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47891 return resultobj;
47892 fail:
47893 return NULL;
47894 }
47895
47896
47897 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47898 PyObject *resultobj = 0;
47899 wxSizer *arg1 = (wxSizer *) 0 ;
47900 wxPoint result;
47901 void *argp1 = 0 ;
47902 int res1 = 0 ;
47903 PyObject *swig_obj[1] ;
47904
47905 if (!args) SWIG_fail;
47906 swig_obj[0] = args;
47907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47908 if (!SWIG_IsOK(res1)) {
47909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47910 }
47911 arg1 = reinterpret_cast< wxSizer * >(argp1);
47912 {
47913 PyThreadState* __tstate = wxPyBeginAllowThreads();
47914 result = (arg1)->GetPosition();
47915 wxPyEndAllowThreads(__tstate);
47916 if (PyErr_Occurred()) SWIG_fail;
47917 }
47918 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47919 return resultobj;
47920 fail:
47921 return NULL;
47922 }
47923
47924
47925 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47926 PyObject *resultobj = 0;
47927 wxSizer *arg1 = (wxSizer *) 0 ;
47928 wxSize result;
47929 void *argp1 = 0 ;
47930 int res1 = 0 ;
47931 PyObject *swig_obj[1] ;
47932
47933 if (!args) SWIG_fail;
47934 swig_obj[0] = args;
47935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47936 if (!SWIG_IsOK(res1)) {
47937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47938 }
47939 arg1 = reinterpret_cast< wxSizer * >(argp1);
47940 {
47941 PyThreadState* __tstate = wxPyBeginAllowThreads();
47942 result = (arg1)->GetMinSize();
47943 wxPyEndAllowThreads(__tstate);
47944 if (PyErr_Occurred()) SWIG_fail;
47945 }
47946 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47947 return resultobj;
47948 fail:
47949 return NULL;
47950 }
47951
47952
47953 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47954 PyObject *resultobj = 0;
47955 wxSizer *arg1 = (wxSizer *) 0 ;
47956 void *argp1 = 0 ;
47957 int res1 = 0 ;
47958 PyObject *swig_obj[1] ;
47959
47960 if (!args) SWIG_fail;
47961 swig_obj[0] = args;
47962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47963 if (!SWIG_IsOK(res1)) {
47964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47965 }
47966 arg1 = reinterpret_cast< wxSizer * >(argp1);
47967 {
47968 PyThreadState* __tstate = wxPyBeginAllowThreads();
47969 (arg1)->RecalcSizes();
47970 wxPyEndAllowThreads(__tstate);
47971 if (PyErr_Occurred()) SWIG_fail;
47972 }
47973 resultobj = SWIG_Py_Void();
47974 return resultobj;
47975 fail:
47976 return NULL;
47977 }
47978
47979
47980 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47981 PyObject *resultobj = 0;
47982 wxSizer *arg1 = (wxSizer *) 0 ;
47983 wxSize result;
47984 void *argp1 = 0 ;
47985 int res1 = 0 ;
47986 PyObject *swig_obj[1] ;
47987
47988 if (!args) SWIG_fail;
47989 swig_obj[0] = args;
47990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47991 if (!SWIG_IsOK(res1)) {
47992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47993 }
47994 arg1 = reinterpret_cast< wxSizer * >(argp1);
47995 {
47996 PyThreadState* __tstate = wxPyBeginAllowThreads();
47997 result = (arg1)->CalcMin();
47998 wxPyEndAllowThreads(__tstate);
47999 if (PyErr_Occurred()) SWIG_fail;
48000 }
48001 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48002 return resultobj;
48003 fail:
48004 return NULL;
48005 }
48006
48007
48008 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48009 PyObject *resultobj = 0;
48010 wxSizer *arg1 = (wxSizer *) 0 ;
48011 void *argp1 = 0 ;
48012 int res1 = 0 ;
48013 PyObject *swig_obj[1] ;
48014
48015 if (!args) SWIG_fail;
48016 swig_obj[0] = args;
48017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48018 if (!SWIG_IsOK(res1)) {
48019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48020 }
48021 arg1 = reinterpret_cast< wxSizer * >(argp1);
48022 {
48023 PyThreadState* __tstate = wxPyBeginAllowThreads();
48024 (arg1)->Layout();
48025 wxPyEndAllowThreads(__tstate);
48026 if (PyErr_Occurred()) SWIG_fail;
48027 }
48028 resultobj = SWIG_Py_Void();
48029 return resultobj;
48030 fail:
48031 return NULL;
48032 }
48033
48034
48035 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48036 PyObject *resultobj = 0;
48037 wxSizer *arg1 = (wxSizer *) 0 ;
48038 wxWindow *arg2 = (wxWindow *) 0 ;
48039 wxSize result;
48040 void *argp1 = 0 ;
48041 int res1 = 0 ;
48042 void *argp2 = 0 ;
48043 int res2 = 0 ;
48044 PyObject * obj0 = 0 ;
48045 PyObject * obj1 = 0 ;
48046 char * kwnames[] = {
48047 (char *) "self",(char *) "window", NULL
48048 };
48049
48050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48052 if (!SWIG_IsOK(res1)) {
48053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48054 }
48055 arg1 = reinterpret_cast< wxSizer * >(argp1);
48056 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48057 if (!SWIG_IsOK(res2)) {
48058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48059 }
48060 arg2 = reinterpret_cast< wxWindow * >(argp2);
48061 {
48062 PyThreadState* __tstate = wxPyBeginAllowThreads();
48063 result = (arg1)->Fit(arg2);
48064 wxPyEndAllowThreads(__tstate);
48065 if (PyErr_Occurred()) SWIG_fail;
48066 }
48067 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48068 return resultobj;
48069 fail:
48070 return NULL;
48071 }
48072
48073
48074 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48075 PyObject *resultobj = 0;
48076 wxSizer *arg1 = (wxSizer *) 0 ;
48077 wxWindow *arg2 = (wxWindow *) 0 ;
48078 void *argp1 = 0 ;
48079 int res1 = 0 ;
48080 void *argp2 = 0 ;
48081 int res2 = 0 ;
48082 PyObject * obj0 = 0 ;
48083 PyObject * obj1 = 0 ;
48084 char * kwnames[] = {
48085 (char *) "self",(char *) "window", NULL
48086 };
48087
48088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48090 if (!SWIG_IsOK(res1)) {
48091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48092 }
48093 arg1 = reinterpret_cast< wxSizer * >(argp1);
48094 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48095 if (!SWIG_IsOK(res2)) {
48096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48097 }
48098 arg2 = reinterpret_cast< wxWindow * >(argp2);
48099 {
48100 PyThreadState* __tstate = wxPyBeginAllowThreads();
48101 (arg1)->FitInside(arg2);
48102 wxPyEndAllowThreads(__tstate);
48103 if (PyErr_Occurred()) SWIG_fail;
48104 }
48105 resultobj = SWIG_Py_Void();
48106 return resultobj;
48107 fail:
48108 return NULL;
48109 }
48110
48111
48112 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48113 PyObject *resultobj = 0;
48114 wxSizer *arg1 = (wxSizer *) 0 ;
48115 wxWindow *arg2 = (wxWindow *) 0 ;
48116 void *argp1 = 0 ;
48117 int res1 = 0 ;
48118 void *argp2 = 0 ;
48119 int res2 = 0 ;
48120 PyObject * obj0 = 0 ;
48121 PyObject * obj1 = 0 ;
48122 char * kwnames[] = {
48123 (char *) "self",(char *) "window", NULL
48124 };
48125
48126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48128 if (!SWIG_IsOK(res1)) {
48129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48130 }
48131 arg1 = reinterpret_cast< wxSizer * >(argp1);
48132 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48133 if (!SWIG_IsOK(res2)) {
48134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48135 }
48136 arg2 = reinterpret_cast< wxWindow * >(argp2);
48137 {
48138 PyThreadState* __tstate = wxPyBeginAllowThreads();
48139 (arg1)->SetSizeHints(arg2);
48140 wxPyEndAllowThreads(__tstate);
48141 if (PyErr_Occurred()) SWIG_fail;
48142 }
48143 resultobj = SWIG_Py_Void();
48144 return resultobj;
48145 fail:
48146 return NULL;
48147 }
48148
48149
48150 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48151 PyObject *resultobj = 0;
48152 wxSizer *arg1 = (wxSizer *) 0 ;
48153 wxWindow *arg2 = (wxWindow *) 0 ;
48154 void *argp1 = 0 ;
48155 int res1 = 0 ;
48156 void *argp2 = 0 ;
48157 int res2 = 0 ;
48158 PyObject * obj0 = 0 ;
48159 PyObject * obj1 = 0 ;
48160 char * kwnames[] = {
48161 (char *) "self",(char *) "window", NULL
48162 };
48163
48164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48166 if (!SWIG_IsOK(res1)) {
48167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48168 }
48169 arg1 = reinterpret_cast< wxSizer * >(argp1);
48170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48171 if (!SWIG_IsOK(res2)) {
48172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48173 }
48174 arg2 = reinterpret_cast< wxWindow * >(argp2);
48175 {
48176 PyThreadState* __tstate = wxPyBeginAllowThreads();
48177 (arg1)->SetVirtualSizeHints(arg2);
48178 wxPyEndAllowThreads(__tstate);
48179 if (PyErr_Occurred()) SWIG_fail;
48180 }
48181 resultobj = SWIG_Py_Void();
48182 return resultobj;
48183 fail:
48184 return NULL;
48185 }
48186
48187
48188 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48189 PyObject *resultobj = 0;
48190 wxSizer *arg1 = (wxSizer *) 0 ;
48191 bool arg2 = (bool) false ;
48192 void *argp1 = 0 ;
48193 int res1 = 0 ;
48194 bool val2 ;
48195 int ecode2 = 0 ;
48196 PyObject * obj0 = 0 ;
48197 PyObject * obj1 = 0 ;
48198 char * kwnames[] = {
48199 (char *) "self",(char *) "deleteWindows", NULL
48200 };
48201
48202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48204 if (!SWIG_IsOK(res1)) {
48205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48206 }
48207 arg1 = reinterpret_cast< wxSizer * >(argp1);
48208 if (obj1) {
48209 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48210 if (!SWIG_IsOK(ecode2)) {
48211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48212 }
48213 arg2 = static_cast< bool >(val2);
48214 }
48215 {
48216 PyThreadState* __tstate = wxPyBeginAllowThreads();
48217 (arg1)->Clear(arg2);
48218 wxPyEndAllowThreads(__tstate);
48219 if (PyErr_Occurred()) SWIG_fail;
48220 }
48221 resultobj = SWIG_Py_Void();
48222 return resultobj;
48223 fail:
48224 return NULL;
48225 }
48226
48227
48228 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48229 PyObject *resultobj = 0;
48230 wxSizer *arg1 = (wxSizer *) 0 ;
48231 void *argp1 = 0 ;
48232 int res1 = 0 ;
48233 PyObject *swig_obj[1] ;
48234
48235 if (!args) SWIG_fail;
48236 swig_obj[0] = args;
48237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48238 if (!SWIG_IsOK(res1)) {
48239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48240 }
48241 arg1 = reinterpret_cast< wxSizer * >(argp1);
48242 {
48243 PyThreadState* __tstate = wxPyBeginAllowThreads();
48244 (arg1)->DeleteWindows();
48245 wxPyEndAllowThreads(__tstate);
48246 if (PyErr_Occurred()) SWIG_fail;
48247 }
48248 resultobj = SWIG_Py_Void();
48249 return resultobj;
48250 fail:
48251 return NULL;
48252 }
48253
48254
48255 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48256 PyObject *resultobj = 0;
48257 wxSizer *arg1 = (wxSizer *) 0 ;
48258 PyObject *result = 0 ;
48259 void *argp1 = 0 ;
48260 int res1 = 0 ;
48261 PyObject *swig_obj[1] ;
48262
48263 if (!args) SWIG_fail;
48264 swig_obj[0] = args;
48265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48266 if (!SWIG_IsOK(res1)) {
48267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48268 }
48269 arg1 = reinterpret_cast< wxSizer * >(argp1);
48270 {
48271 PyThreadState* __tstate = wxPyBeginAllowThreads();
48272 result = (PyObject *)wxSizer_GetChildren(arg1);
48273 wxPyEndAllowThreads(__tstate);
48274 if (PyErr_Occurred()) SWIG_fail;
48275 }
48276 resultobj = result;
48277 return resultobj;
48278 fail:
48279 return NULL;
48280 }
48281
48282
48283 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48284 PyObject *resultobj = 0;
48285 wxSizer *arg1 = (wxSizer *) 0 ;
48286 PyObject *arg2 = (PyObject *) 0 ;
48287 bool arg3 = (bool) true ;
48288 bool arg4 = (bool) false ;
48289 bool result;
48290 void *argp1 = 0 ;
48291 int res1 = 0 ;
48292 bool val3 ;
48293 int ecode3 = 0 ;
48294 bool val4 ;
48295 int ecode4 = 0 ;
48296 PyObject * obj0 = 0 ;
48297 PyObject * obj1 = 0 ;
48298 PyObject * obj2 = 0 ;
48299 PyObject * obj3 = 0 ;
48300 char * kwnames[] = {
48301 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48302 };
48303
48304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48306 if (!SWIG_IsOK(res1)) {
48307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48308 }
48309 arg1 = reinterpret_cast< wxSizer * >(argp1);
48310 arg2 = obj1;
48311 if (obj2) {
48312 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48313 if (!SWIG_IsOK(ecode3)) {
48314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48315 }
48316 arg3 = static_cast< bool >(val3);
48317 }
48318 if (obj3) {
48319 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48320 if (!SWIG_IsOK(ecode4)) {
48321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48322 }
48323 arg4 = static_cast< bool >(val4);
48324 }
48325 {
48326 PyThreadState* __tstate = wxPyBeginAllowThreads();
48327 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48328 wxPyEndAllowThreads(__tstate);
48329 if (PyErr_Occurred()) SWIG_fail;
48330 }
48331 {
48332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48333 }
48334 return resultobj;
48335 fail:
48336 return NULL;
48337 }
48338
48339
48340 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48341 PyObject *resultobj = 0;
48342 wxSizer *arg1 = (wxSizer *) 0 ;
48343 PyObject *arg2 = (PyObject *) 0 ;
48344 bool result;
48345 void *argp1 = 0 ;
48346 int res1 = 0 ;
48347 PyObject * obj0 = 0 ;
48348 PyObject * obj1 = 0 ;
48349 char * kwnames[] = {
48350 (char *) "self",(char *) "item", NULL
48351 };
48352
48353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48355 if (!SWIG_IsOK(res1)) {
48356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48357 }
48358 arg1 = reinterpret_cast< wxSizer * >(argp1);
48359 arg2 = obj1;
48360 {
48361 PyThreadState* __tstate = wxPyBeginAllowThreads();
48362 result = (bool)wxSizer_IsShown(arg1,arg2);
48363 wxPyEndAllowThreads(__tstate);
48364 if (PyErr_Occurred()) SWIG_fail;
48365 }
48366 {
48367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48368 }
48369 return resultobj;
48370 fail:
48371 return NULL;
48372 }
48373
48374
48375 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48376 PyObject *resultobj = 0;
48377 wxSizer *arg1 = (wxSizer *) 0 ;
48378 bool arg2 ;
48379 void *argp1 = 0 ;
48380 int res1 = 0 ;
48381 bool val2 ;
48382 int ecode2 = 0 ;
48383 PyObject * obj0 = 0 ;
48384 PyObject * obj1 = 0 ;
48385 char * kwnames[] = {
48386 (char *) "self",(char *) "show", NULL
48387 };
48388
48389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48391 if (!SWIG_IsOK(res1)) {
48392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48393 }
48394 arg1 = reinterpret_cast< wxSizer * >(argp1);
48395 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48396 if (!SWIG_IsOK(ecode2)) {
48397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48398 }
48399 arg2 = static_cast< bool >(val2);
48400 {
48401 PyThreadState* __tstate = wxPyBeginAllowThreads();
48402 (arg1)->ShowItems(arg2);
48403 wxPyEndAllowThreads(__tstate);
48404 if (PyErr_Occurred()) SWIG_fail;
48405 }
48406 resultobj = SWIG_Py_Void();
48407 return resultobj;
48408 fail:
48409 return NULL;
48410 }
48411
48412
48413 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48414 PyObject *obj;
48415 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48416 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48417 return SWIG_Py_Void();
48418 }
48419
48420 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48421 PyObject *resultobj = 0;
48422 wxPySizer *result = 0 ;
48423
48424 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48425 {
48426 PyThreadState* __tstate = wxPyBeginAllowThreads();
48427 result = (wxPySizer *)new wxPySizer();
48428 wxPyEndAllowThreads(__tstate);
48429 if (PyErr_Occurred()) SWIG_fail;
48430 }
48431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48432 return resultobj;
48433 fail:
48434 return NULL;
48435 }
48436
48437
48438 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48439 PyObject *resultobj = 0;
48440 wxPySizer *arg1 = (wxPySizer *) 0 ;
48441 PyObject *arg2 = (PyObject *) 0 ;
48442 PyObject *arg3 = (PyObject *) 0 ;
48443 void *argp1 = 0 ;
48444 int res1 = 0 ;
48445 PyObject * obj0 = 0 ;
48446 PyObject * obj1 = 0 ;
48447 PyObject * obj2 = 0 ;
48448 char * kwnames[] = {
48449 (char *) "self",(char *) "self",(char *) "_class", NULL
48450 };
48451
48452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48454 if (!SWIG_IsOK(res1)) {
48455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48456 }
48457 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48458 arg2 = obj1;
48459 arg3 = obj2;
48460 {
48461 PyThreadState* __tstate = wxPyBeginAllowThreads();
48462 (arg1)->_setCallbackInfo(arg2,arg3);
48463 wxPyEndAllowThreads(__tstate);
48464 if (PyErr_Occurred()) SWIG_fail;
48465 }
48466 resultobj = SWIG_Py_Void();
48467 return resultobj;
48468 fail:
48469 return NULL;
48470 }
48471
48472
48473 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48474 PyObject *obj;
48475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48476 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48477 return SWIG_Py_Void();
48478 }
48479
48480 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48481 return SWIG_Python_InitShadowInstance(args);
48482 }
48483
48484 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48485 PyObject *resultobj = 0;
48486 int arg1 = (int) wxHORIZONTAL ;
48487 wxBoxSizer *result = 0 ;
48488 int val1 ;
48489 int ecode1 = 0 ;
48490 PyObject * obj0 = 0 ;
48491 char * kwnames[] = {
48492 (char *) "orient", NULL
48493 };
48494
48495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48496 if (obj0) {
48497 ecode1 = SWIG_AsVal_int(obj0, &val1);
48498 if (!SWIG_IsOK(ecode1)) {
48499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48500 }
48501 arg1 = static_cast< int >(val1);
48502 }
48503 {
48504 PyThreadState* __tstate = wxPyBeginAllowThreads();
48505 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48506 wxPyEndAllowThreads(__tstate);
48507 if (PyErr_Occurred()) SWIG_fail;
48508 }
48509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48510 return resultobj;
48511 fail:
48512 return NULL;
48513 }
48514
48515
48516 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48517 PyObject *resultobj = 0;
48518 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48519 int result;
48520 void *argp1 = 0 ;
48521 int res1 = 0 ;
48522 PyObject *swig_obj[1] ;
48523
48524 if (!args) SWIG_fail;
48525 swig_obj[0] = args;
48526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48527 if (!SWIG_IsOK(res1)) {
48528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48529 }
48530 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48531 {
48532 PyThreadState* __tstate = wxPyBeginAllowThreads();
48533 result = (int)(arg1)->GetOrientation();
48534 wxPyEndAllowThreads(__tstate);
48535 if (PyErr_Occurred()) SWIG_fail;
48536 }
48537 resultobj = SWIG_From_int(static_cast< int >(result));
48538 return resultobj;
48539 fail:
48540 return NULL;
48541 }
48542
48543
48544 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48545 PyObject *resultobj = 0;
48546 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48547 int arg2 ;
48548 void *argp1 = 0 ;
48549 int res1 = 0 ;
48550 int val2 ;
48551 int ecode2 = 0 ;
48552 PyObject * obj0 = 0 ;
48553 PyObject * obj1 = 0 ;
48554 char * kwnames[] = {
48555 (char *) "self",(char *) "orient", NULL
48556 };
48557
48558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48560 if (!SWIG_IsOK(res1)) {
48561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48562 }
48563 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48564 ecode2 = SWIG_AsVal_int(obj1, &val2);
48565 if (!SWIG_IsOK(ecode2)) {
48566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48567 }
48568 arg2 = static_cast< int >(val2);
48569 {
48570 PyThreadState* __tstate = wxPyBeginAllowThreads();
48571 (arg1)->SetOrientation(arg2);
48572 wxPyEndAllowThreads(__tstate);
48573 if (PyErr_Occurred()) SWIG_fail;
48574 }
48575 resultobj = SWIG_Py_Void();
48576 return resultobj;
48577 fail:
48578 return NULL;
48579 }
48580
48581
48582 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48583 PyObject *obj;
48584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48585 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48586 return SWIG_Py_Void();
48587 }
48588
48589 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48590 return SWIG_Python_InitShadowInstance(args);
48591 }
48592
48593 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48594 PyObject *resultobj = 0;
48595 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48596 int arg2 = (int) wxHORIZONTAL ;
48597 wxStaticBoxSizer *result = 0 ;
48598 void *argp1 = 0 ;
48599 int res1 = 0 ;
48600 int val2 ;
48601 int ecode2 = 0 ;
48602 PyObject * obj0 = 0 ;
48603 PyObject * obj1 = 0 ;
48604 char * kwnames[] = {
48605 (char *) "box",(char *) "orient", NULL
48606 };
48607
48608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48610 if (!SWIG_IsOK(res1)) {
48611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48612 }
48613 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48614 if (obj1) {
48615 ecode2 = SWIG_AsVal_int(obj1, &val2);
48616 if (!SWIG_IsOK(ecode2)) {
48617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48618 }
48619 arg2 = static_cast< int >(val2);
48620 }
48621 {
48622 PyThreadState* __tstate = wxPyBeginAllowThreads();
48623 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48624 wxPyEndAllowThreads(__tstate);
48625 if (PyErr_Occurred()) SWIG_fail;
48626 }
48627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48628 return resultobj;
48629 fail:
48630 return NULL;
48631 }
48632
48633
48634 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48635 PyObject *resultobj = 0;
48636 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48637 wxStaticBox *result = 0 ;
48638 void *argp1 = 0 ;
48639 int res1 = 0 ;
48640 PyObject *swig_obj[1] ;
48641
48642 if (!args) SWIG_fail;
48643 swig_obj[0] = args;
48644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48645 if (!SWIG_IsOK(res1)) {
48646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48647 }
48648 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48649 {
48650 PyThreadState* __tstate = wxPyBeginAllowThreads();
48651 result = (wxStaticBox *)(arg1)->GetStaticBox();
48652 wxPyEndAllowThreads(__tstate);
48653 if (PyErr_Occurred()) SWIG_fail;
48654 }
48655 {
48656 resultobj = wxPyMake_wxObject(result, (bool)0);
48657 }
48658 return resultobj;
48659 fail:
48660 return NULL;
48661 }
48662
48663
48664 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48665 PyObject *obj;
48666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48667 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48668 return SWIG_Py_Void();
48669 }
48670
48671 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48672 return SWIG_Python_InitShadowInstance(args);
48673 }
48674
48675 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48676 PyObject *resultobj = 0;
48677 int arg1 = (int) 1 ;
48678 int arg2 = (int) 0 ;
48679 int arg3 = (int) 0 ;
48680 int arg4 = (int) 0 ;
48681 wxGridSizer *result = 0 ;
48682 int val1 ;
48683 int ecode1 = 0 ;
48684 int val2 ;
48685 int ecode2 = 0 ;
48686 int val3 ;
48687 int ecode3 = 0 ;
48688 int val4 ;
48689 int ecode4 = 0 ;
48690 PyObject * obj0 = 0 ;
48691 PyObject * obj1 = 0 ;
48692 PyObject * obj2 = 0 ;
48693 PyObject * obj3 = 0 ;
48694 char * kwnames[] = {
48695 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48696 };
48697
48698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48699 if (obj0) {
48700 ecode1 = SWIG_AsVal_int(obj0, &val1);
48701 if (!SWIG_IsOK(ecode1)) {
48702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48703 }
48704 arg1 = static_cast< int >(val1);
48705 }
48706 if (obj1) {
48707 ecode2 = SWIG_AsVal_int(obj1, &val2);
48708 if (!SWIG_IsOK(ecode2)) {
48709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48710 }
48711 arg2 = static_cast< int >(val2);
48712 }
48713 if (obj2) {
48714 ecode3 = SWIG_AsVal_int(obj2, &val3);
48715 if (!SWIG_IsOK(ecode3)) {
48716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48717 }
48718 arg3 = static_cast< int >(val3);
48719 }
48720 if (obj3) {
48721 ecode4 = SWIG_AsVal_int(obj3, &val4);
48722 if (!SWIG_IsOK(ecode4)) {
48723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48724 }
48725 arg4 = static_cast< int >(val4);
48726 }
48727 {
48728 PyThreadState* __tstate = wxPyBeginAllowThreads();
48729 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48730 wxPyEndAllowThreads(__tstate);
48731 if (PyErr_Occurred()) SWIG_fail;
48732 }
48733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48734 return resultobj;
48735 fail:
48736 return NULL;
48737 }
48738
48739
48740 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48741 PyObject *resultobj = 0;
48742 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48743 int arg2 ;
48744 void *argp1 = 0 ;
48745 int res1 = 0 ;
48746 int val2 ;
48747 int ecode2 = 0 ;
48748 PyObject * obj0 = 0 ;
48749 PyObject * obj1 = 0 ;
48750 char * kwnames[] = {
48751 (char *) "self",(char *) "cols", NULL
48752 };
48753
48754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48756 if (!SWIG_IsOK(res1)) {
48757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48758 }
48759 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48760 ecode2 = SWIG_AsVal_int(obj1, &val2);
48761 if (!SWIG_IsOK(ecode2)) {
48762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48763 }
48764 arg2 = static_cast< int >(val2);
48765 {
48766 PyThreadState* __tstate = wxPyBeginAllowThreads();
48767 (arg1)->SetCols(arg2);
48768 wxPyEndAllowThreads(__tstate);
48769 if (PyErr_Occurred()) SWIG_fail;
48770 }
48771 resultobj = SWIG_Py_Void();
48772 return resultobj;
48773 fail:
48774 return NULL;
48775 }
48776
48777
48778 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48779 PyObject *resultobj = 0;
48780 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48781 int arg2 ;
48782 void *argp1 = 0 ;
48783 int res1 = 0 ;
48784 int val2 ;
48785 int ecode2 = 0 ;
48786 PyObject * obj0 = 0 ;
48787 PyObject * obj1 = 0 ;
48788 char * kwnames[] = {
48789 (char *) "self",(char *) "rows", NULL
48790 };
48791
48792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48794 if (!SWIG_IsOK(res1)) {
48795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48796 }
48797 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48798 ecode2 = SWIG_AsVal_int(obj1, &val2);
48799 if (!SWIG_IsOK(ecode2)) {
48800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48801 }
48802 arg2 = static_cast< int >(val2);
48803 {
48804 PyThreadState* __tstate = wxPyBeginAllowThreads();
48805 (arg1)->SetRows(arg2);
48806 wxPyEndAllowThreads(__tstate);
48807 if (PyErr_Occurred()) SWIG_fail;
48808 }
48809 resultobj = SWIG_Py_Void();
48810 return resultobj;
48811 fail:
48812 return NULL;
48813 }
48814
48815
48816 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48817 PyObject *resultobj = 0;
48818 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48819 int arg2 ;
48820 void *argp1 = 0 ;
48821 int res1 = 0 ;
48822 int val2 ;
48823 int ecode2 = 0 ;
48824 PyObject * obj0 = 0 ;
48825 PyObject * obj1 = 0 ;
48826 char * kwnames[] = {
48827 (char *) "self",(char *) "gap", NULL
48828 };
48829
48830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48832 if (!SWIG_IsOK(res1)) {
48833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48834 }
48835 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48836 ecode2 = SWIG_AsVal_int(obj1, &val2);
48837 if (!SWIG_IsOK(ecode2)) {
48838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48839 }
48840 arg2 = static_cast< int >(val2);
48841 {
48842 PyThreadState* __tstate = wxPyBeginAllowThreads();
48843 (arg1)->SetVGap(arg2);
48844 wxPyEndAllowThreads(__tstate);
48845 if (PyErr_Occurred()) SWIG_fail;
48846 }
48847 resultobj = SWIG_Py_Void();
48848 return resultobj;
48849 fail:
48850 return NULL;
48851 }
48852
48853
48854 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48855 PyObject *resultobj = 0;
48856 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48857 int arg2 ;
48858 void *argp1 = 0 ;
48859 int res1 = 0 ;
48860 int val2 ;
48861 int ecode2 = 0 ;
48862 PyObject * obj0 = 0 ;
48863 PyObject * obj1 = 0 ;
48864 char * kwnames[] = {
48865 (char *) "self",(char *) "gap", NULL
48866 };
48867
48868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48870 if (!SWIG_IsOK(res1)) {
48871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48872 }
48873 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48874 ecode2 = SWIG_AsVal_int(obj1, &val2);
48875 if (!SWIG_IsOK(ecode2)) {
48876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48877 }
48878 arg2 = static_cast< int >(val2);
48879 {
48880 PyThreadState* __tstate = wxPyBeginAllowThreads();
48881 (arg1)->SetHGap(arg2);
48882 wxPyEndAllowThreads(__tstate);
48883 if (PyErr_Occurred()) SWIG_fail;
48884 }
48885 resultobj = SWIG_Py_Void();
48886 return resultobj;
48887 fail:
48888 return NULL;
48889 }
48890
48891
48892 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48893 PyObject *resultobj = 0;
48894 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48895 int result;
48896 void *argp1 = 0 ;
48897 int res1 = 0 ;
48898 PyObject *swig_obj[1] ;
48899
48900 if (!args) SWIG_fail;
48901 swig_obj[0] = args;
48902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48903 if (!SWIG_IsOK(res1)) {
48904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48905 }
48906 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48907 {
48908 PyThreadState* __tstate = wxPyBeginAllowThreads();
48909 result = (int)(arg1)->GetCols();
48910 wxPyEndAllowThreads(__tstate);
48911 if (PyErr_Occurred()) SWIG_fail;
48912 }
48913 resultobj = SWIG_From_int(static_cast< int >(result));
48914 return resultobj;
48915 fail:
48916 return NULL;
48917 }
48918
48919
48920 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48921 PyObject *resultobj = 0;
48922 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48923 int result;
48924 void *argp1 = 0 ;
48925 int res1 = 0 ;
48926 PyObject *swig_obj[1] ;
48927
48928 if (!args) SWIG_fail;
48929 swig_obj[0] = args;
48930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48931 if (!SWIG_IsOK(res1)) {
48932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48933 }
48934 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48935 {
48936 PyThreadState* __tstate = wxPyBeginAllowThreads();
48937 result = (int)(arg1)->GetRows();
48938 wxPyEndAllowThreads(__tstate);
48939 if (PyErr_Occurred()) SWIG_fail;
48940 }
48941 resultobj = SWIG_From_int(static_cast< int >(result));
48942 return resultobj;
48943 fail:
48944 return NULL;
48945 }
48946
48947
48948 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48949 PyObject *resultobj = 0;
48950 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48951 int result;
48952 void *argp1 = 0 ;
48953 int res1 = 0 ;
48954 PyObject *swig_obj[1] ;
48955
48956 if (!args) SWIG_fail;
48957 swig_obj[0] = args;
48958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48959 if (!SWIG_IsOK(res1)) {
48960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48961 }
48962 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48963 {
48964 PyThreadState* __tstate = wxPyBeginAllowThreads();
48965 result = (int)(arg1)->GetVGap();
48966 wxPyEndAllowThreads(__tstate);
48967 if (PyErr_Occurred()) SWIG_fail;
48968 }
48969 resultobj = SWIG_From_int(static_cast< int >(result));
48970 return resultobj;
48971 fail:
48972 return NULL;
48973 }
48974
48975
48976 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48977 PyObject *resultobj = 0;
48978 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48979 int result;
48980 void *argp1 = 0 ;
48981 int res1 = 0 ;
48982 PyObject *swig_obj[1] ;
48983
48984 if (!args) SWIG_fail;
48985 swig_obj[0] = args;
48986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48987 if (!SWIG_IsOK(res1)) {
48988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48989 }
48990 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48991 {
48992 PyThreadState* __tstate = wxPyBeginAllowThreads();
48993 result = (int)(arg1)->GetHGap();
48994 wxPyEndAllowThreads(__tstate);
48995 if (PyErr_Occurred()) SWIG_fail;
48996 }
48997 resultobj = SWIG_From_int(static_cast< int >(result));
48998 return resultobj;
48999 fail:
49000 return NULL;
49001 }
49002
49003
49004 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49005 PyObject *obj;
49006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49007 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49008 return SWIG_Py_Void();
49009 }
49010
49011 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49012 return SWIG_Python_InitShadowInstance(args);
49013 }
49014
49015 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49016 PyObject *resultobj = 0;
49017 int arg1 = (int) 1 ;
49018 int arg2 = (int) 0 ;
49019 int arg3 = (int) 0 ;
49020 int arg4 = (int) 0 ;
49021 wxFlexGridSizer *result = 0 ;
49022 int val1 ;
49023 int ecode1 = 0 ;
49024 int val2 ;
49025 int ecode2 = 0 ;
49026 int val3 ;
49027 int ecode3 = 0 ;
49028 int val4 ;
49029 int ecode4 = 0 ;
49030 PyObject * obj0 = 0 ;
49031 PyObject * obj1 = 0 ;
49032 PyObject * obj2 = 0 ;
49033 PyObject * obj3 = 0 ;
49034 char * kwnames[] = {
49035 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49036 };
49037
49038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49039 if (obj0) {
49040 ecode1 = SWIG_AsVal_int(obj0, &val1);
49041 if (!SWIG_IsOK(ecode1)) {
49042 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49043 }
49044 arg1 = static_cast< int >(val1);
49045 }
49046 if (obj1) {
49047 ecode2 = SWIG_AsVal_int(obj1, &val2);
49048 if (!SWIG_IsOK(ecode2)) {
49049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49050 }
49051 arg2 = static_cast< int >(val2);
49052 }
49053 if (obj2) {
49054 ecode3 = SWIG_AsVal_int(obj2, &val3);
49055 if (!SWIG_IsOK(ecode3)) {
49056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49057 }
49058 arg3 = static_cast< int >(val3);
49059 }
49060 if (obj3) {
49061 ecode4 = SWIG_AsVal_int(obj3, &val4);
49062 if (!SWIG_IsOK(ecode4)) {
49063 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49064 }
49065 arg4 = static_cast< int >(val4);
49066 }
49067 {
49068 PyThreadState* __tstate = wxPyBeginAllowThreads();
49069 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49070 wxPyEndAllowThreads(__tstate);
49071 if (PyErr_Occurred()) SWIG_fail;
49072 }
49073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49074 return resultobj;
49075 fail:
49076 return NULL;
49077 }
49078
49079
49080 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49081 PyObject *resultobj = 0;
49082 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49083 size_t arg2 ;
49084 int arg3 = (int) 0 ;
49085 void *argp1 = 0 ;
49086 int res1 = 0 ;
49087 size_t val2 ;
49088 int ecode2 = 0 ;
49089 int val3 ;
49090 int ecode3 = 0 ;
49091 PyObject * obj0 = 0 ;
49092 PyObject * obj1 = 0 ;
49093 PyObject * obj2 = 0 ;
49094 char * kwnames[] = {
49095 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49096 };
49097
49098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49100 if (!SWIG_IsOK(res1)) {
49101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49102 }
49103 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49104 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49105 if (!SWIG_IsOK(ecode2)) {
49106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49107 }
49108 arg2 = static_cast< size_t >(val2);
49109 if (obj2) {
49110 ecode3 = SWIG_AsVal_int(obj2, &val3);
49111 if (!SWIG_IsOK(ecode3)) {
49112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49113 }
49114 arg3 = static_cast< int >(val3);
49115 }
49116 {
49117 PyThreadState* __tstate = wxPyBeginAllowThreads();
49118 (arg1)->AddGrowableRow(arg2,arg3);
49119 wxPyEndAllowThreads(__tstate);
49120 if (PyErr_Occurred()) SWIG_fail;
49121 }
49122 resultobj = SWIG_Py_Void();
49123 return resultobj;
49124 fail:
49125 return NULL;
49126 }
49127
49128
49129 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49130 PyObject *resultobj = 0;
49131 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49132 size_t arg2 ;
49133 void *argp1 = 0 ;
49134 int res1 = 0 ;
49135 size_t val2 ;
49136 int ecode2 = 0 ;
49137 PyObject * obj0 = 0 ;
49138 PyObject * obj1 = 0 ;
49139 char * kwnames[] = {
49140 (char *) "self",(char *) "idx", NULL
49141 };
49142
49143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49145 if (!SWIG_IsOK(res1)) {
49146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49147 }
49148 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49149 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49150 if (!SWIG_IsOK(ecode2)) {
49151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49152 }
49153 arg2 = static_cast< size_t >(val2);
49154 {
49155 PyThreadState* __tstate = wxPyBeginAllowThreads();
49156 (arg1)->RemoveGrowableRow(arg2);
49157 wxPyEndAllowThreads(__tstate);
49158 if (PyErr_Occurred()) SWIG_fail;
49159 }
49160 resultobj = SWIG_Py_Void();
49161 return resultobj;
49162 fail:
49163 return NULL;
49164 }
49165
49166
49167 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49168 PyObject *resultobj = 0;
49169 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49170 size_t arg2 ;
49171 int arg3 = (int) 0 ;
49172 void *argp1 = 0 ;
49173 int res1 = 0 ;
49174 size_t val2 ;
49175 int ecode2 = 0 ;
49176 int val3 ;
49177 int ecode3 = 0 ;
49178 PyObject * obj0 = 0 ;
49179 PyObject * obj1 = 0 ;
49180 PyObject * obj2 = 0 ;
49181 char * kwnames[] = {
49182 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49183 };
49184
49185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49187 if (!SWIG_IsOK(res1)) {
49188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49189 }
49190 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49191 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49192 if (!SWIG_IsOK(ecode2)) {
49193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49194 }
49195 arg2 = static_cast< size_t >(val2);
49196 if (obj2) {
49197 ecode3 = SWIG_AsVal_int(obj2, &val3);
49198 if (!SWIG_IsOK(ecode3)) {
49199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49200 }
49201 arg3 = static_cast< int >(val3);
49202 }
49203 {
49204 PyThreadState* __tstate = wxPyBeginAllowThreads();
49205 (arg1)->AddGrowableCol(arg2,arg3);
49206 wxPyEndAllowThreads(__tstate);
49207 if (PyErr_Occurred()) SWIG_fail;
49208 }
49209 resultobj = SWIG_Py_Void();
49210 return resultobj;
49211 fail:
49212 return NULL;
49213 }
49214
49215
49216 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49217 PyObject *resultobj = 0;
49218 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49219 size_t arg2 ;
49220 void *argp1 = 0 ;
49221 int res1 = 0 ;
49222 size_t val2 ;
49223 int ecode2 = 0 ;
49224 PyObject * obj0 = 0 ;
49225 PyObject * obj1 = 0 ;
49226 char * kwnames[] = {
49227 (char *) "self",(char *) "idx", NULL
49228 };
49229
49230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49232 if (!SWIG_IsOK(res1)) {
49233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49234 }
49235 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49236 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49237 if (!SWIG_IsOK(ecode2)) {
49238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49239 }
49240 arg2 = static_cast< size_t >(val2);
49241 {
49242 PyThreadState* __tstate = wxPyBeginAllowThreads();
49243 (arg1)->RemoveGrowableCol(arg2);
49244 wxPyEndAllowThreads(__tstate);
49245 if (PyErr_Occurred()) SWIG_fail;
49246 }
49247 resultobj = SWIG_Py_Void();
49248 return resultobj;
49249 fail:
49250 return NULL;
49251 }
49252
49253
49254 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49255 PyObject *resultobj = 0;
49256 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49257 int arg2 ;
49258 void *argp1 = 0 ;
49259 int res1 = 0 ;
49260 int val2 ;
49261 int ecode2 = 0 ;
49262 PyObject * obj0 = 0 ;
49263 PyObject * obj1 = 0 ;
49264 char * kwnames[] = {
49265 (char *) "self",(char *) "direction", NULL
49266 };
49267
49268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49270 if (!SWIG_IsOK(res1)) {
49271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49272 }
49273 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49274 ecode2 = SWIG_AsVal_int(obj1, &val2);
49275 if (!SWIG_IsOK(ecode2)) {
49276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49277 }
49278 arg2 = static_cast< int >(val2);
49279 {
49280 PyThreadState* __tstate = wxPyBeginAllowThreads();
49281 (arg1)->SetFlexibleDirection(arg2);
49282 wxPyEndAllowThreads(__tstate);
49283 if (PyErr_Occurred()) SWIG_fail;
49284 }
49285 resultobj = SWIG_Py_Void();
49286 return resultobj;
49287 fail:
49288 return NULL;
49289 }
49290
49291
49292 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49293 PyObject *resultobj = 0;
49294 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49295 int result;
49296 void *argp1 = 0 ;
49297 int res1 = 0 ;
49298 PyObject *swig_obj[1] ;
49299
49300 if (!args) SWIG_fail;
49301 swig_obj[0] = args;
49302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49303 if (!SWIG_IsOK(res1)) {
49304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49305 }
49306 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49307 {
49308 PyThreadState* __tstate = wxPyBeginAllowThreads();
49309 result = (int)(arg1)->GetFlexibleDirection();
49310 wxPyEndAllowThreads(__tstate);
49311 if (PyErr_Occurred()) SWIG_fail;
49312 }
49313 resultobj = SWIG_From_int(static_cast< int >(result));
49314 return resultobj;
49315 fail:
49316 return NULL;
49317 }
49318
49319
49320 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49321 PyObject *resultobj = 0;
49322 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49323 wxFlexSizerGrowMode arg2 ;
49324 void *argp1 = 0 ;
49325 int res1 = 0 ;
49326 int val2 ;
49327 int ecode2 = 0 ;
49328 PyObject * obj0 = 0 ;
49329 PyObject * obj1 = 0 ;
49330 char * kwnames[] = {
49331 (char *) "self",(char *) "mode", NULL
49332 };
49333
49334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49336 if (!SWIG_IsOK(res1)) {
49337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49338 }
49339 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49340 ecode2 = SWIG_AsVal_int(obj1, &val2);
49341 if (!SWIG_IsOK(ecode2)) {
49342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49343 }
49344 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49345 {
49346 PyThreadState* __tstate = wxPyBeginAllowThreads();
49347 (arg1)->SetNonFlexibleGrowMode(arg2);
49348 wxPyEndAllowThreads(__tstate);
49349 if (PyErr_Occurred()) SWIG_fail;
49350 }
49351 resultobj = SWIG_Py_Void();
49352 return resultobj;
49353 fail:
49354 return NULL;
49355 }
49356
49357
49358 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49359 PyObject *resultobj = 0;
49360 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49361 wxFlexSizerGrowMode result;
49362 void *argp1 = 0 ;
49363 int res1 = 0 ;
49364 PyObject *swig_obj[1] ;
49365
49366 if (!args) SWIG_fail;
49367 swig_obj[0] = args;
49368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49369 if (!SWIG_IsOK(res1)) {
49370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49371 }
49372 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49373 {
49374 PyThreadState* __tstate = wxPyBeginAllowThreads();
49375 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49376 wxPyEndAllowThreads(__tstate);
49377 if (PyErr_Occurred()) SWIG_fail;
49378 }
49379 resultobj = SWIG_From_int(static_cast< int >(result));
49380 return resultobj;
49381 fail:
49382 return NULL;
49383 }
49384
49385
49386 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49387 PyObject *resultobj = 0;
49388 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49389 wxArrayInt *result = 0 ;
49390 void *argp1 = 0 ;
49391 int res1 = 0 ;
49392 PyObject *swig_obj[1] ;
49393
49394 if (!args) SWIG_fail;
49395 swig_obj[0] = args;
49396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49397 if (!SWIG_IsOK(res1)) {
49398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49399 }
49400 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49401 {
49402 PyThreadState* __tstate = wxPyBeginAllowThreads();
49403 {
49404 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49405 result = (wxArrayInt *) &_result_ref;
49406 }
49407 wxPyEndAllowThreads(__tstate);
49408 if (PyErr_Occurred()) SWIG_fail;
49409 }
49410 {
49411 resultobj = PyList_New(0);
49412 size_t idx;
49413 for (idx = 0; idx < result->GetCount(); idx += 1) {
49414 PyObject* val = PyInt_FromLong( result->Item(idx) );
49415 PyList_Append(resultobj, val);
49416 Py_DECREF(val);
49417 }
49418 }
49419 return resultobj;
49420 fail:
49421 return NULL;
49422 }
49423
49424
49425 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49426 PyObject *resultobj = 0;
49427 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49428 wxArrayInt *result = 0 ;
49429 void *argp1 = 0 ;
49430 int res1 = 0 ;
49431 PyObject *swig_obj[1] ;
49432
49433 if (!args) SWIG_fail;
49434 swig_obj[0] = args;
49435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49436 if (!SWIG_IsOK(res1)) {
49437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49438 }
49439 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49440 {
49441 PyThreadState* __tstate = wxPyBeginAllowThreads();
49442 {
49443 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49444 result = (wxArrayInt *) &_result_ref;
49445 }
49446 wxPyEndAllowThreads(__tstate);
49447 if (PyErr_Occurred()) SWIG_fail;
49448 }
49449 {
49450 resultobj = PyList_New(0);
49451 size_t idx;
49452 for (idx = 0; idx < result->GetCount(); idx += 1) {
49453 PyObject* val = PyInt_FromLong( result->Item(idx) );
49454 PyList_Append(resultobj, val);
49455 Py_DECREF(val);
49456 }
49457 }
49458 return resultobj;
49459 fail:
49460 return NULL;
49461 }
49462
49463
49464 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49465 PyObject *obj;
49466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49467 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49468 return SWIG_Py_Void();
49469 }
49470
49471 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49472 return SWIG_Python_InitShadowInstance(args);
49473 }
49474
49475 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49476 PyObject *resultobj = 0;
49477 wxStdDialogButtonSizer *result = 0 ;
49478
49479 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49480 {
49481 PyThreadState* __tstate = wxPyBeginAllowThreads();
49482 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49483 wxPyEndAllowThreads(__tstate);
49484 if (PyErr_Occurred()) SWIG_fail;
49485 }
49486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49487 return resultobj;
49488 fail:
49489 return NULL;
49490 }
49491
49492
49493 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49494 PyObject *resultobj = 0;
49495 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49496 wxButton *arg2 = (wxButton *) 0 ;
49497 void *argp1 = 0 ;
49498 int res1 = 0 ;
49499 void *argp2 = 0 ;
49500 int res2 = 0 ;
49501 PyObject * obj0 = 0 ;
49502 PyObject * obj1 = 0 ;
49503 char * kwnames[] = {
49504 (char *) "self",(char *) "button", NULL
49505 };
49506
49507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49509 if (!SWIG_IsOK(res1)) {
49510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49511 }
49512 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49514 if (!SWIG_IsOK(res2)) {
49515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49516 }
49517 arg2 = reinterpret_cast< wxButton * >(argp2);
49518 {
49519 PyThreadState* __tstate = wxPyBeginAllowThreads();
49520 (arg1)->AddButton(arg2);
49521 wxPyEndAllowThreads(__tstate);
49522 if (PyErr_Occurred()) SWIG_fail;
49523 }
49524 resultobj = SWIG_Py_Void();
49525 return resultobj;
49526 fail:
49527 return NULL;
49528 }
49529
49530
49531 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49532 PyObject *resultobj = 0;
49533 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49534 void *argp1 = 0 ;
49535 int res1 = 0 ;
49536 PyObject *swig_obj[1] ;
49537
49538 if (!args) SWIG_fail;
49539 swig_obj[0] = args;
49540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49541 if (!SWIG_IsOK(res1)) {
49542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49543 }
49544 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49545 {
49546 PyThreadState* __tstate = wxPyBeginAllowThreads();
49547 (arg1)->Realize();
49548 wxPyEndAllowThreads(__tstate);
49549 if (PyErr_Occurred()) SWIG_fail;
49550 }
49551 resultobj = SWIG_Py_Void();
49552 return resultobj;
49553 fail:
49554 return NULL;
49555 }
49556
49557
49558 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49559 PyObject *resultobj = 0;
49560 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49561 wxButton *arg2 = (wxButton *) 0 ;
49562 void *argp1 = 0 ;
49563 int res1 = 0 ;
49564 void *argp2 = 0 ;
49565 int res2 = 0 ;
49566 PyObject * obj0 = 0 ;
49567 PyObject * obj1 = 0 ;
49568 char * kwnames[] = {
49569 (char *) "self",(char *) "button", NULL
49570 };
49571
49572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49574 if (!SWIG_IsOK(res1)) {
49575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49576 }
49577 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49579 if (!SWIG_IsOK(res2)) {
49580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49581 }
49582 arg2 = reinterpret_cast< wxButton * >(argp2);
49583 {
49584 PyThreadState* __tstate = wxPyBeginAllowThreads();
49585 (arg1)->SetAffirmativeButton(arg2);
49586 wxPyEndAllowThreads(__tstate);
49587 if (PyErr_Occurred()) SWIG_fail;
49588 }
49589 resultobj = SWIG_Py_Void();
49590 return resultobj;
49591 fail:
49592 return NULL;
49593 }
49594
49595
49596 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49597 PyObject *resultobj = 0;
49598 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49599 wxButton *arg2 = (wxButton *) 0 ;
49600 void *argp1 = 0 ;
49601 int res1 = 0 ;
49602 void *argp2 = 0 ;
49603 int res2 = 0 ;
49604 PyObject * obj0 = 0 ;
49605 PyObject * obj1 = 0 ;
49606 char * kwnames[] = {
49607 (char *) "self",(char *) "button", NULL
49608 };
49609
49610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49612 if (!SWIG_IsOK(res1)) {
49613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49614 }
49615 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49617 if (!SWIG_IsOK(res2)) {
49618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49619 }
49620 arg2 = reinterpret_cast< wxButton * >(argp2);
49621 {
49622 PyThreadState* __tstate = wxPyBeginAllowThreads();
49623 (arg1)->SetNegativeButton(arg2);
49624 wxPyEndAllowThreads(__tstate);
49625 if (PyErr_Occurred()) SWIG_fail;
49626 }
49627 resultobj = SWIG_Py_Void();
49628 return resultobj;
49629 fail:
49630 return NULL;
49631 }
49632
49633
49634 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49635 PyObject *resultobj = 0;
49636 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49637 wxButton *arg2 = (wxButton *) 0 ;
49638 void *argp1 = 0 ;
49639 int res1 = 0 ;
49640 void *argp2 = 0 ;
49641 int res2 = 0 ;
49642 PyObject * obj0 = 0 ;
49643 PyObject * obj1 = 0 ;
49644 char * kwnames[] = {
49645 (char *) "self",(char *) "button", NULL
49646 };
49647
49648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49650 if (!SWIG_IsOK(res1)) {
49651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49652 }
49653 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49655 if (!SWIG_IsOK(res2)) {
49656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49657 }
49658 arg2 = reinterpret_cast< wxButton * >(argp2);
49659 {
49660 PyThreadState* __tstate = wxPyBeginAllowThreads();
49661 (arg1)->SetCancelButton(arg2);
49662 wxPyEndAllowThreads(__tstate);
49663 if (PyErr_Occurred()) SWIG_fail;
49664 }
49665 resultobj = SWIG_Py_Void();
49666 return resultobj;
49667 fail:
49668 return NULL;
49669 }
49670
49671
49672 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49673 PyObject *resultobj = 0;
49674 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49675 wxButton *result = 0 ;
49676 void *argp1 = 0 ;
49677 int res1 = 0 ;
49678 PyObject *swig_obj[1] ;
49679
49680 if (!args) SWIG_fail;
49681 swig_obj[0] = args;
49682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49683 if (!SWIG_IsOK(res1)) {
49684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49685 }
49686 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49687 {
49688 PyThreadState* __tstate = wxPyBeginAllowThreads();
49689 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49690 wxPyEndAllowThreads(__tstate);
49691 if (PyErr_Occurred()) SWIG_fail;
49692 }
49693 {
49694 resultobj = wxPyMake_wxObject(result, (bool)0);
49695 }
49696 return resultobj;
49697 fail:
49698 return NULL;
49699 }
49700
49701
49702 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49703 PyObject *resultobj = 0;
49704 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49705 wxButton *result = 0 ;
49706 void *argp1 = 0 ;
49707 int res1 = 0 ;
49708 PyObject *swig_obj[1] ;
49709
49710 if (!args) SWIG_fail;
49711 swig_obj[0] = args;
49712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49713 if (!SWIG_IsOK(res1)) {
49714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49715 }
49716 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49717 {
49718 PyThreadState* __tstate = wxPyBeginAllowThreads();
49719 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49720 wxPyEndAllowThreads(__tstate);
49721 if (PyErr_Occurred()) SWIG_fail;
49722 }
49723 {
49724 resultobj = wxPyMake_wxObject(result, (bool)0);
49725 }
49726 return resultobj;
49727 fail:
49728 return NULL;
49729 }
49730
49731
49732 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49733 PyObject *resultobj = 0;
49734 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49735 wxButton *result = 0 ;
49736 void *argp1 = 0 ;
49737 int res1 = 0 ;
49738 PyObject *swig_obj[1] ;
49739
49740 if (!args) SWIG_fail;
49741 swig_obj[0] = args;
49742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49743 if (!SWIG_IsOK(res1)) {
49744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49745 }
49746 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49747 {
49748 PyThreadState* __tstate = wxPyBeginAllowThreads();
49749 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49750 wxPyEndAllowThreads(__tstate);
49751 if (PyErr_Occurred()) SWIG_fail;
49752 }
49753 {
49754 resultobj = wxPyMake_wxObject(result, (bool)0);
49755 }
49756 return resultobj;
49757 fail:
49758 return NULL;
49759 }
49760
49761
49762 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49763 PyObject *resultobj = 0;
49764 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49765 wxButton *result = 0 ;
49766 void *argp1 = 0 ;
49767 int res1 = 0 ;
49768 PyObject *swig_obj[1] ;
49769
49770 if (!args) SWIG_fail;
49771 swig_obj[0] = args;
49772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49773 if (!SWIG_IsOK(res1)) {
49774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49775 }
49776 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49777 {
49778 PyThreadState* __tstate = wxPyBeginAllowThreads();
49779 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49780 wxPyEndAllowThreads(__tstate);
49781 if (PyErr_Occurred()) SWIG_fail;
49782 }
49783 {
49784 resultobj = wxPyMake_wxObject(result, (bool)0);
49785 }
49786 return resultobj;
49787 fail:
49788 return NULL;
49789 }
49790
49791
49792 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49793 PyObject *resultobj = 0;
49794 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49795 wxButton *result = 0 ;
49796 void *argp1 = 0 ;
49797 int res1 = 0 ;
49798 PyObject *swig_obj[1] ;
49799
49800 if (!args) SWIG_fail;
49801 swig_obj[0] = args;
49802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49803 if (!SWIG_IsOK(res1)) {
49804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49805 }
49806 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49807 {
49808 PyThreadState* __tstate = wxPyBeginAllowThreads();
49809 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49810 wxPyEndAllowThreads(__tstate);
49811 if (PyErr_Occurred()) SWIG_fail;
49812 }
49813 {
49814 resultobj = wxPyMake_wxObject(result, (bool)0);
49815 }
49816 return resultobj;
49817 fail:
49818 return NULL;
49819 }
49820
49821
49822 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49823 PyObject *obj;
49824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49825 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49826 return SWIG_Py_Void();
49827 }
49828
49829 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49830 return SWIG_Python_InitShadowInstance(args);
49831 }
49832
49833 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49834 PyObject *resultobj = 0;
49835 int arg1 = (int) 0 ;
49836 int arg2 = (int) 0 ;
49837 wxGBPosition *result = 0 ;
49838 int val1 ;
49839 int ecode1 = 0 ;
49840 int val2 ;
49841 int ecode2 = 0 ;
49842 PyObject * obj0 = 0 ;
49843 PyObject * obj1 = 0 ;
49844 char * kwnames[] = {
49845 (char *) "row",(char *) "col", NULL
49846 };
49847
49848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49849 if (obj0) {
49850 ecode1 = SWIG_AsVal_int(obj0, &val1);
49851 if (!SWIG_IsOK(ecode1)) {
49852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49853 }
49854 arg1 = static_cast< int >(val1);
49855 }
49856 if (obj1) {
49857 ecode2 = SWIG_AsVal_int(obj1, &val2);
49858 if (!SWIG_IsOK(ecode2)) {
49859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49860 }
49861 arg2 = static_cast< int >(val2);
49862 }
49863 {
49864 PyThreadState* __tstate = wxPyBeginAllowThreads();
49865 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49866 wxPyEndAllowThreads(__tstate);
49867 if (PyErr_Occurred()) SWIG_fail;
49868 }
49869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49870 return resultobj;
49871 fail:
49872 return NULL;
49873 }
49874
49875
49876 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49877 PyObject *resultobj = 0;
49878 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49879 void *argp1 = 0 ;
49880 int res1 = 0 ;
49881 PyObject *swig_obj[1] ;
49882
49883 if (!args) SWIG_fail;
49884 swig_obj[0] = args;
49885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49886 if (!SWIG_IsOK(res1)) {
49887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49888 }
49889 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49890 {
49891 PyThreadState* __tstate = wxPyBeginAllowThreads();
49892 delete arg1;
49893
49894 wxPyEndAllowThreads(__tstate);
49895 if (PyErr_Occurred()) SWIG_fail;
49896 }
49897 resultobj = SWIG_Py_Void();
49898 return resultobj;
49899 fail:
49900 return NULL;
49901 }
49902
49903
49904 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49905 PyObject *resultobj = 0;
49906 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49907 int result;
49908 void *argp1 = 0 ;
49909 int res1 = 0 ;
49910 PyObject *swig_obj[1] ;
49911
49912 if (!args) SWIG_fail;
49913 swig_obj[0] = args;
49914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49915 if (!SWIG_IsOK(res1)) {
49916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49917 }
49918 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49919 {
49920 PyThreadState* __tstate = wxPyBeginAllowThreads();
49921 result = (int)((wxGBPosition const *)arg1)->GetRow();
49922 wxPyEndAllowThreads(__tstate);
49923 if (PyErr_Occurred()) SWIG_fail;
49924 }
49925 resultobj = SWIG_From_int(static_cast< int >(result));
49926 return resultobj;
49927 fail:
49928 return NULL;
49929 }
49930
49931
49932 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49933 PyObject *resultobj = 0;
49934 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49935 int result;
49936 void *argp1 = 0 ;
49937 int res1 = 0 ;
49938 PyObject *swig_obj[1] ;
49939
49940 if (!args) SWIG_fail;
49941 swig_obj[0] = args;
49942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49943 if (!SWIG_IsOK(res1)) {
49944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49945 }
49946 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49947 {
49948 PyThreadState* __tstate = wxPyBeginAllowThreads();
49949 result = (int)((wxGBPosition const *)arg1)->GetCol();
49950 wxPyEndAllowThreads(__tstate);
49951 if (PyErr_Occurred()) SWIG_fail;
49952 }
49953 resultobj = SWIG_From_int(static_cast< int >(result));
49954 return resultobj;
49955 fail:
49956 return NULL;
49957 }
49958
49959
49960 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49961 PyObject *resultobj = 0;
49962 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49963 int arg2 ;
49964 void *argp1 = 0 ;
49965 int res1 = 0 ;
49966 int val2 ;
49967 int ecode2 = 0 ;
49968 PyObject * obj0 = 0 ;
49969 PyObject * obj1 = 0 ;
49970 char * kwnames[] = {
49971 (char *) "self",(char *) "row", NULL
49972 };
49973
49974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49976 if (!SWIG_IsOK(res1)) {
49977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49978 }
49979 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49980 ecode2 = SWIG_AsVal_int(obj1, &val2);
49981 if (!SWIG_IsOK(ecode2)) {
49982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49983 }
49984 arg2 = static_cast< int >(val2);
49985 {
49986 PyThreadState* __tstate = wxPyBeginAllowThreads();
49987 (arg1)->SetRow(arg2);
49988 wxPyEndAllowThreads(__tstate);
49989 if (PyErr_Occurred()) SWIG_fail;
49990 }
49991 resultobj = SWIG_Py_Void();
49992 return resultobj;
49993 fail:
49994 return NULL;
49995 }
49996
49997
49998 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49999 PyObject *resultobj = 0;
50000 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50001 int arg2 ;
50002 void *argp1 = 0 ;
50003 int res1 = 0 ;
50004 int val2 ;
50005 int ecode2 = 0 ;
50006 PyObject * obj0 = 0 ;
50007 PyObject * obj1 = 0 ;
50008 char * kwnames[] = {
50009 (char *) "self",(char *) "col", NULL
50010 };
50011
50012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50014 if (!SWIG_IsOK(res1)) {
50015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50016 }
50017 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50018 ecode2 = SWIG_AsVal_int(obj1, &val2);
50019 if (!SWIG_IsOK(ecode2)) {
50020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50021 }
50022 arg2 = static_cast< int >(val2);
50023 {
50024 PyThreadState* __tstate = wxPyBeginAllowThreads();
50025 (arg1)->SetCol(arg2);
50026 wxPyEndAllowThreads(__tstate);
50027 if (PyErr_Occurred()) SWIG_fail;
50028 }
50029 resultobj = SWIG_Py_Void();
50030 return resultobj;
50031 fail:
50032 return NULL;
50033 }
50034
50035
50036 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50037 PyObject *resultobj = 0;
50038 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50039 PyObject *arg2 = (PyObject *) 0 ;
50040 bool result;
50041 void *argp1 = 0 ;
50042 int res1 = 0 ;
50043 PyObject * obj0 = 0 ;
50044 PyObject * obj1 = 0 ;
50045 char * kwnames[] = {
50046 (char *) "self",(char *) "other", NULL
50047 };
50048
50049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50051 if (!SWIG_IsOK(res1)) {
50052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50053 }
50054 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50055 arg2 = obj1;
50056 {
50057 result = (bool)wxGBPosition___eq__(arg1,arg2);
50058 if (PyErr_Occurred()) SWIG_fail;
50059 }
50060 {
50061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50062 }
50063 return resultobj;
50064 fail:
50065 return NULL;
50066 }
50067
50068
50069 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50070 PyObject *resultobj = 0;
50071 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50072 PyObject *arg2 = (PyObject *) 0 ;
50073 bool result;
50074 void *argp1 = 0 ;
50075 int res1 = 0 ;
50076 PyObject * obj0 = 0 ;
50077 PyObject * obj1 = 0 ;
50078 char * kwnames[] = {
50079 (char *) "self",(char *) "other", NULL
50080 };
50081
50082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50084 if (!SWIG_IsOK(res1)) {
50085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50086 }
50087 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50088 arg2 = obj1;
50089 {
50090 result = (bool)wxGBPosition___ne__(arg1,arg2);
50091 if (PyErr_Occurred()) SWIG_fail;
50092 }
50093 {
50094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50095 }
50096 return resultobj;
50097 fail:
50098 return NULL;
50099 }
50100
50101
50102 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50103 PyObject *resultobj = 0;
50104 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50105 int arg2 = (int) 0 ;
50106 int arg3 = (int) 0 ;
50107 void *argp1 = 0 ;
50108 int res1 = 0 ;
50109 int val2 ;
50110 int ecode2 = 0 ;
50111 int val3 ;
50112 int ecode3 = 0 ;
50113 PyObject * obj0 = 0 ;
50114 PyObject * obj1 = 0 ;
50115 PyObject * obj2 = 0 ;
50116 char * kwnames[] = {
50117 (char *) "self",(char *) "row",(char *) "col", NULL
50118 };
50119
50120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50122 if (!SWIG_IsOK(res1)) {
50123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50124 }
50125 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50126 if (obj1) {
50127 ecode2 = SWIG_AsVal_int(obj1, &val2);
50128 if (!SWIG_IsOK(ecode2)) {
50129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50130 }
50131 arg2 = static_cast< int >(val2);
50132 }
50133 if (obj2) {
50134 ecode3 = SWIG_AsVal_int(obj2, &val3);
50135 if (!SWIG_IsOK(ecode3)) {
50136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50137 }
50138 arg3 = static_cast< int >(val3);
50139 }
50140 {
50141 PyThreadState* __tstate = wxPyBeginAllowThreads();
50142 wxGBPosition_Set(arg1,arg2,arg3);
50143 wxPyEndAllowThreads(__tstate);
50144 if (PyErr_Occurred()) SWIG_fail;
50145 }
50146 resultobj = SWIG_Py_Void();
50147 return resultobj;
50148 fail:
50149 return NULL;
50150 }
50151
50152
50153 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50154 PyObject *resultobj = 0;
50155 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50156 PyObject *result = 0 ;
50157 void *argp1 = 0 ;
50158 int res1 = 0 ;
50159 PyObject *swig_obj[1] ;
50160
50161 if (!args) SWIG_fail;
50162 swig_obj[0] = args;
50163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50164 if (!SWIG_IsOK(res1)) {
50165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50166 }
50167 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50168 {
50169 PyThreadState* __tstate = wxPyBeginAllowThreads();
50170 result = (PyObject *)wxGBPosition_Get(arg1);
50171 wxPyEndAllowThreads(__tstate);
50172 if (PyErr_Occurred()) SWIG_fail;
50173 }
50174 resultobj = result;
50175 return resultobj;
50176 fail:
50177 return NULL;
50178 }
50179
50180
50181 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50182 PyObject *obj;
50183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50184 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50185 return SWIG_Py_Void();
50186 }
50187
50188 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50189 return SWIG_Python_InitShadowInstance(args);
50190 }
50191
50192 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50193 PyObject *resultobj = 0;
50194 int arg1 = (int) 1 ;
50195 int arg2 = (int) 1 ;
50196 wxGBSpan *result = 0 ;
50197 int val1 ;
50198 int ecode1 = 0 ;
50199 int val2 ;
50200 int ecode2 = 0 ;
50201 PyObject * obj0 = 0 ;
50202 PyObject * obj1 = 0 ;
50203 char * kwnames[] = {
50204 (char *) "rowspan",(char *) "colspan", NULL
50205 };
50206
50207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50208 if (obj0) {
50209 ecode1 = SWIG_AsVal_int(obj0, &val1);
50210 if (!SWIG_IsOK(ecode1)) {
50211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50212 }
50213 arg1 = static_cast< int >(val1);
50214 }
50215 if (obj1) {
50216 ecode2 = SWIG_AsVal_int(obj1, &val2);
50217 if (!SWIG_IsOK(ecode2)) {
50218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50219 }
50220 arg2 = static_cast< int >(val2);
50221 }
50222 {
50223 PyThreadState* __tstate = wxPyBeginAllowThreads();
50224 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50225 wxPyEndAllowThreads(__tstate);
50226 if (PyErr_Occurred()) SWIG_fail;
50227 }
50228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50229 return resultobj;
50230 fail:
50231 return NULL;
50232 }
50233
50234
50235 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50236 PyObject *resultobj = 0;
50237 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50238 void *argp1 = 0 ;
50239 int res1 = 0 ;
50240 PyObject *swig_obj[1] ;
50241
50242 if (!args) SWIG_fail;
50243 swig_obj[0] = args;
50244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50245 if (!SWIG_IsOK(res1)) {
50246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50247 }
50248 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50249 {
50250 PyThreadState* __tstate = wxPyBeginAllowThreads();
50251 delete arg1;
50252
50253 wxPyEndAllowThreads(__tstate);
50254 if (PyErr_Occurred()) SWIG_fail;
50255 }
50256 resultobj = SWIG_Py_Void();
50257 return resultobj;
50258 fail:
50259 return NULL;
50260 }
50261
50262
50263 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50264 PyObject *resultobj = 0;
50265 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50266 int result;
50267 void *argp1 = 0 ;
50268 int res1 = 0 ;
50269 PyObject *swig_obj[1] ;
50270
50271 if (!args) SWIG_fail;
50272 swig_obj[0] = args;
50273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50274 if (!SWIG_IsOK(res1)) {
50275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50276 }
50277 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50278 {
50279 PyThreadState* __tstate = wxPyBeginAllowThreads();
50280 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50281 wxPyEndAllowThreads(__tstate);
50282 if (PyErr_Occurred()) SWIG_fail;
50283 }
50284 resultobj = SWIG_From_int(static_cast< int >(result));
50285 return resultobj;
50286 fail:
50287 return NULL;
50288 }
50289
50290
50291 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50292 PyObject *resultobj = 0;
50293 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50294 int result;
50295 void *argp1 = 0 ;
50296 int res1 = 0 ;
50297 PyObject *swig_obj[1] ;
50298
50299 if (!args) SWIG_fail;
50300 swig_obj[0] = args;
50301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50302 if (!SWIG_IsOK(res1)) {
50303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50304 }
50305 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50306 {
50307 PyThreadState* __tstate = wxPyBeginAllowThreads();
50308 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50309 wxPyEndAllowThreads(__tstate);
50310 if (PyErr_Occurred()) SWIG_fail;
50311 }
50312 resultobj = SWIG_From_int(static_cast< int >(result));
50313 return resultobj;
50314 fail:
50315 return NULL;
50316 }
50317
50318
50319 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50320 PyObject *resultobj = 0;
50321 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50322 int arg2 ;
50323 void *argp1 = 0 ;
50324 int res1 = 0 ;
50325 int val2 ;
50326 int ecode2 = 0 ;
50327 PyObject * obj0 = 0 ;
50328 PyObject * obj1 = 0 ;
50329 char * kwnames[] = {
50330 (char *) "self",(char *) "rowspan", NULL
50331 };
50332
50333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50335 if (!SWIG_IsOK(res1)) {
50336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50337 }
50338 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50339 ecode2 = SWIG_AsVal_int(obj1, &val2);
50340 if (!SWIG_IsOK(ecode2)) {
50341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50342 }
50343 arg2 = static_cast< int >(val2);
50344 {
50345 PyThreadState* __tstate = wxPyBeginAllowThreads();
50346 (arg1)->SetRowspan(arg2);
50347 wxPyEndAllowThreads(__tstate);
50348 if (PyErr_Occurred()) SWIG_fail;
50349 }
50350 resultobj = SWIG_Py_Void();
50351 return resultobj;
50352 fail:
50353 return NULL;
50354 }
50355
50356
50357 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50358 PyObject *resultobj = 0;
50359 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50360 int arg2 ;
50361 void *argp1 = 0 ;
50362 int res1 = 0 ;
50363 int val2 ;
50364 int ecode2 = 0 ;
50365 PyObject * obj0 = 0 ;
50366 PyObject * obj1 = 0 ;
50367 char * kwnames[] = {
50368 (char *) "self",(char *) "colspan", NULL
50369 };
50370
50371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50373 if (!SWIG_IsOK(res1)) {
50374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50375 }
50376 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50377 ecode2 = SWIG_AsVal_int(obj1, &val2);
50378 if (!SWIG_IsOK(ecode2)) {
50379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50380 }
50381 arg2 = static_cast< int >(val2);
50382 {
50383 PyThreadState* __tstate = wxPyBeginAllowThreads();
50384 (arg1)->SetColspan(arg2);
50385 wxPyEndAllowThreads(__tstate);
50386 if (PyErr_Occurred()) SWIG_fail;
50387 }
50388 resultobj = SWIG_Py_Void();
50389 return resultobj;
50390 fail:
50391 return NULL;
50392 }
50393
50394
50395 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50396 PyObject *resultobj = 0;
50397 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50398 PyObject *arg2 = (PyObject *) 0 ;
50399 bool result;
50400 void *argp1 = 0 ;
50401 int res1 = 0 ;
50402 PyObject * obj0 = 0 ;
50403 PyObject * obj1 = 0 ;
50404 char * kwnames[] = {
50405 (char *) "self",(char *) "other", NULL
50406 };
50407
50408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50410 if (!SWIG_IsOK(res1)) {
50411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50412 }
50413 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50414 arg2 = obj1;
50415 {
50416 result = (bool)wxGBSpan___eq__(arg1,arg2);
50417 if (PyErr_Occurred()) SWIG_fail;
50418 }
50419 {
50420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50421 }
50422 return resultobj;
50423 fail:
50424 return NULL;
50425 }
50426
50427
50428 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50429 PyObject *resultobj = 0;
50430 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50431 PyObject *arg2 = (PyObject *) 0 ;
50432 bool result;
50433 void *argp1 = 0 ;
50434 int res1 = 0 ;
50435 PyObject * obj0 = 0 ;
50436 PyObject * obj1 = 0 ;
50437 char * kwnames[] = {
50438 (char *) "self",(char *) "other", NULL
50439 };
50440
50441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50443 if (!SWIG_IsOK(res1)) {
50444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50445 }
50446 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50447 arg2 = obj1;
50448 {
50449 result = (bool)wxGBSpan___ne__(arg1,arg2);
50450 if (PyErr_Occurred()) SWIG_fail;
50451 }
50452 {
50453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50454 }
50455 return resultobj;
50456 fail:
50457 return NULL;
50458 }
50459
50460
50461 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50462 PyObject *resultobj = 0;
50463 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50464 int arg2 = (int) 1 ;
50465 int arg3 = (int) 1 ;
50466 void *argp1 = 0 ;
50467 int res1 = 0 ;
50468 int val2 ;
50469 int ecode2 = 0 ;
50470 int val3 ;
50471 int ecode3 = 0 ;
50472 PyObject * obj0 = 0 ;
50473 PyObject * obj1 = 0 ;
50474 PyObject * obj2 = 0 ;
50475 char * kwnames[] = {
50476 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50477 };
50478
50479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50481 if (!SWIG_IsOK(res1)) {
50482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50483 }
50484 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50485 if (obj1) {
50486 ecode2 = SWIG_AsVal_int(obj1, &val2);
50487 if (!SWIG_IsOK(ecode2)) {
50488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50489 }
50490 arg2 = static_cast< int >(val2);
50491 }
50492 if (obj2) {
50493 ecode3 = SWIG_AsVal_int(obj2, &val3);
50494 if (!SWIG_IsOK(ecode3)) {
50495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50496 }
50497 arg3 = static_cast< int >(val3);
50498 }
50499 {
50500 PyThreadState* __tstate = wxPyBeginAllowThreads();
50501 wxGBSpan_Set(arg1,arg2,arg3);
50502 wxPyEndAllowThreads(__tstate);
50503 if (PyErr_Occurred()) SWIG_fail;
50504 }
50505 resultobj = SWIG_Py_Void();
50506 return resultobj;
50507 fail:
50508 return NULL;
50509 }
50510
50511
50512 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50513 PyObject *resultobj = 0;
50514 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50515 PyObject *result = 0 ;
50516 void *argp1 = 0 ;
50517 int res1 = 0 ;
50518 PyObject *swig_obj[1] ;
50519
50520 if (!args) SWIG_fail;
50521 swig_obj[0] = args;
50522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50523 if (!SWIG_IsOK(res1)) {
50524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50525 }
50526 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50527 {
50528 PyThreadState* __tstate = wxPyBeginAllowThreads();
50529 result = (PyObject *)wxGBSpan_Get(arg1);
50530 wxPyEndAllowThreads(__tstate);
50531 if (PyErr_Occurred()) SWIG_fail;
50532 }
50533 resultobj = result;
50534 return resultobj;
50535 fail:
50536 return NULL;
50537 }
50538
50539
50540 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50541 PyObject *obj;
50542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50543 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50544 return SWIG_Py_Void();
50545 }
50546
50547 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50548 return SWIG_Python_InitShadowInstance(args);
50549 }
50550
50551 SWIGINTERN int DefaultSpan_set(PyObject *) {
50552 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50553 return 1;
50554 }
50555
50556
50557 SWIGINTERN PyObject *DefaultSpan_get(void) {
50558 PyObject *pyobj = 0;
50559
50560 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50561 return pyobj;
50562 }
50563
50564
50565 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50566 PyObject *resultobj = 0;
50567 wxGBSizerItem *result = 0 ;
50568
50569 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50570 {
50571 PyThreadState* __tstate = wxPyBeginAllowThreads();
50572 result = (wxGBSizerItem *)new wxGBSizerItem();
50573 wxPyEndAllowThreads(__tstate);
50574 if (PyErr_Occurred()) SWIG_fail;
50575 }
50576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50577 return resultobj;
50578 fail:
50579 return NULL;
50580 }
50581
50582
50583 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50584 PyObject *resultobj = 0;
50585 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50586 void *argp1 = 0 ;
50587 int res1 = 0 ;
50588 PyObject *swig_obj[1] ;
50589
50590 if (!args) SWIG_fail;
50591 swig_obj[0] = args;
50592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50593 if (!SWIG_IsOK(res1)) {
50594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50595 }
50596 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50597 {
50598 PyThreadState* __tstate = wxPyBeginAllowThreads();
50599 delete arg1;
50600
50601 wxPyEndAllowThreads(__tstate);
50602 if (PyErr_Occurred()) SWIG_fail;
50603 }
50604 resultobj = SWIG_Py_Void();
50605 return resultobj;
50606 fail:
50607 return NULL;
50608 }
50609
50610
50611 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50612 PyObject *resultobj = 0;
50613 wxWindow *arg1 = (wxWindow *) 0 ;
50614 wxGBPosition *arg2 = 0 ;
50615 wxGBSpan *arg3 = 0 ;
50616 int arg4 ;
50617 int arg5 ;
50618 PyObject *arg6 = (PyObject *) NULL ;
50619 wxGBSizerItem *result = 0 ;
50620 void *argp1 = 0 ;
50621 int res1 = 0 ;
50622 wxGBPosition temp2 ;
50623 wxGBSpan temp3 ;
50624 int val4 ;
50625 int ecode4 = 0 ;
50626 int val5 ;
50627 int ecode5 = 0 ;
50628 PyObject * obj0 = 0 ;
50629 PyObject * obj1 = 0 ;
50630 PyObject * obj2 = 0 ;
50631 PyObject * obj3 = 0 ;
50632 PyObject * obj4 = 0 ;
50633 PyObject * obj5 = 0 ;
50634 char * kwnames[] = {
50635 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50636 };
50637
50638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50640 if (!SWIG_IsOK(res1)) {
50641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50642 }
50643 arg1 = reinterpret_cast< wxWindow * >(argp1);
50644 {
50645 arg2 = &temp2;
50646 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50647 }
50648 {
50649 arg3 = &temp3;
50650 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50651 }
50652 ecode4 = SWIG_AsVal_int(obj3, &val4);
50653 if (!SWIG_IsOK(ecode4)) {
50654 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50655 }
50656 arg4 = static_cast< int >(val4);
50657 ecode5 = SWIG_AsVal_int(obj4, &val5);
50658 if (!SWIG_IsOK(ecode5)) {
50659 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50660 }
50661 arg5 = static_cast< int >(val5);
50662 if (obj5) {
50663 arg6 = obj5;
50664 }
50665 {
50666 PyThreadState* __tstate = wxPyBeginAllowThreads();
50667 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50668 wxPyEndAllowThreads(__tstate);
50669 if (PyErr_Occurred()) SWIG_fail;
50670 }
50671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50672 return resultobj;
50673 fail:
50674 return NULL;
50675 }
50676
50677
50678 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50679 PyObject *resultobj = 0;
50680 wxSizer *arg1 = (wxSizer *) 0 ;
50681 wxGBPosition *arg2 = 0 ;
50682 wxGBSpan *arg3 = 0 ;
50683 int arg4 ;
50684 int arg5 ;
50685 PyObject *arg6 = (PyObject *) NULL ;
50686 wxGBSizerItem *result = 0 ;
50687 int res1 = 0 ;
50688 wxGBPosition temp2 ;
50689 wxGBSpan temp3 ;
50690 int val4 ;
50691 int ecode4 = 0 ;
50692 int val5 ;
50693 int ecode5 = 0 ;
50694 PyObject * obj0 = 0 ;
50695 PyObject * obj1 = 0 ;
50696 PyObject * obj2 = 0 ;
50697 PyObject * obj3 = 0 ;
50698 PyObject * obj4 = 0 ;
50699 PyObject * obj5 = 0 ;
50700 char * kwnames[] = {
50701 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50702 };
50703
50704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50705 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50706 if (!SWIG_IsOK(res1)) {
50707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50708 }
50709 {
50710 arg2 = &temp2;
50711 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50712 }
50713 {
50714 arg3 = &temp3;
50715 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50716 }
50717 ecode4 = SWIG_AsVal_int(obj3, &val4);
50718 if (!SWIG_IsOK(ecode4)) {
50719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50720 }
50721 arg4 = static_cast< int >(val4);
50722 ecode5 = SWIG_AsVal_int(obj4, &val5);
50723 if (!SWIG_IsOK(ecode5)) {
50724 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50725 }
50726 arg5 = static_cast< int >(val5);
50727 if (obj5) {
50728 arg6 = obj5;
50729 }
50730 {
50731 PyThreadState* __tstate = wxPyBeginAllowThreads();
50732 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50733 wxPyEndAllowThreads(__tstate);
50734 if (PyErr_Occurred()) SWIG_fail;
50735 }
50736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50737 return resultobj;
50738 fail:
50739 return NULL;
50740 }
50741
50742
50743 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50744 PyObject *resultobj = 0;
50745 int arg1 ;
50746 int arg2 ;
50747 wxGBPosition *arg3 = 0 ;
50748 wxGBSpan *arg4 = 0 ;
50749 int arg5 ;
50750 int arg6 ;
50751 PyObject *arg7 = (PyObject *) NULL ;
50752 wxGBSizerItem *result = 0 ;
50753 int val1 ;
50754 int ecode1 = 0 ;
50755 int val2 ;
50756 int ecode2 = 0 ;
50757 wxGBPosition temp3 ;
50758 wxGBSpan temp4 ;
50759 int val5 ;
50760 int ecode5 = 0 ;
50761 int val6 ;
50762 int ecode6 = 0 ;
50763 PyObject * obj0 = 0 ;
50764 PyObject * obj1 = 0 ;
50765 PyObject * obj2 = 0 ;
50766 PyObject * obj3 = 0 ;
50767 PyObject * obj4 = 0 ;
50768 PyObject * obj5 = 0 ;
50769 PyObject * obj6 = 0 ;
50770 char * kwnames[] = {
50771 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50772 };
50773
50774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50775 ecode1 = SWIG_AsVal_int(obj0, &val1);
50776 if (!SWIG_IsOK(ecode1)) {
50777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50778 }
50779 arg1 = static_cast< int >(val1);
50780 ecode2 = SWIG_AsVal_int(obj1, &val2);
50781 if (!SWIG_IsOK(ecode2)) {
50782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50783 }
50784 arg2 = static_cast< int >(val2);
50785 {
50786 arg3 = &temp3;
50787 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50788 }
50789 {
50790 arg4 = &temp4;
50791 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50792 }
50793 ecode5 = SWIG_AsVal_int(obj4, &val5);
50794 if (!SWIG_IsOK(ecode5)) {
50795 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50796 }
50797 arg5 = static_cast< int >(val5);
50798 ecode6 = SWIG_AsVal_int(obj5, &val6);
50799 if (!SWIG_IsOK(ecode6)) {
50800 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50801 }
50802 arg6 = static_cast< int >(val6);
50803 if (obj6) {
50804 arg7 = obj6;
50805 }
50806 {
50807 PyThreadState* __tstate = wxPyBeginAllowThreads();
50808 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50809 wxPyEndAllowThreads(__tstate);
50810 if (PyErr_Occurred()) SWIG_fail;
50811 }
50812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50813 return resultobj;
50814 fail:
50815 return NULL;
50816 }
50817
50818
50819 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50820 PyObject *resultobj = 0;
50821 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50822 wxGBPosition result;
50823 void *argp1 = 0 ;
50824 int res1 = 0 ;
50825 PyObject *swig_obj[1] ;
50826
50827 if (!args) SWIG_fail;
50828 swig_obj[0] = args;
50829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50830 if (!SWIG_IsOK(res1)) {
50831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50832 }
50833 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50834 {
50835 PyThreadState* __tstate = wxPyBeginAllowThreads();
50836 result = ((wxGBSizerItem const *)arg1)->GetPos();
50837 wxPyEndAllowThreads(__tstate);
50838 if (PyErr_Occurred()) SWIG_fail;
50839 }
50840 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50841 return resultobj;
50842 fail:
50843 return NULL;
50844 }
50845
50846
50847 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50848 PyObject *resultobj = 0;
50849 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50850 wxGBSpan result;
50851 void *argp1 = 0 ;
50852 int res1 = 0 ;
50853 PyObject *swig_obj[1] ;
50854
50855 if (!args) SWIG_fail;
50856 swig_obj[0] = args;
50857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50858 if (!SWIG_IsOK(res1)) {
50859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50860 }
50861 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50862 {
50863 PyThreadState* __tstate = wxPyBeginAllowThreads();
50864 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50865 wxPyEndAllowThreads(__tstate);
50866 if (PyErr_Occurred()) SWIG_fail;
50867 }
50868 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50869 return resultobj;
50870 fail:
50871 return NULL;
50872 }
50873
50874
50875 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50876 PyObject *resultobj = 0;
50877 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50878 wxGBPosition *arg2 = 0 ;
50879 bool result;
50880 void *argp1 = 0 ;
50881 int res1 = 0 ;
50882 wxGBPosition temp2 ;
50883 PyObject * obj0 = 0 ;
50884 PyObject * obj1 = 0 ;
50885 char * kwnames[] = {
50886 (char *) "self",(char *) "pos", NULL
50887 };
50888
50889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50891 if (!SWIG_IsOK(res1)) {
50892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50893 }
50894 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50895 {
50896 arg2 = &temp2;
50897 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50898 }
50899 {
50900 PyThreadState* __tstate = wxPyBeginAllowThreads();
50901 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50902 wxPyEndAllowThreads(__tstate);
50903 if (PyErr_Occurred()) SWIG_fail;
50904 }
50905 {
50906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50907 }
50908 return resultobj;
50909 fail:
50910 return NULL;
50911 }
50912
50913
50914 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50915 PyObject *resultobj = 0;
50916 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50917 wxGBSpan *arg2 = 0 ;
50918 bool result;
50919 void *argp1 = 0 ;
50920 int res1 = 0 ;
50921 wxGBSpan temp2 ;
50922 PyObject * obj0 = 0 ;
50923 PyObject * obj1 = 0 ;
50924 char * kwnames[] = {
50925 (char *) "self",(char *) "span", NULL
50926 };
50927
50928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50930 if (!SWIG_IsOK(res1)) {
50931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50932 }
50933 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50934 {
50935 arg2 = &temp2;
50936 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50937 }
50938 {
50939 PyThreadState* __tstate = wxPyBeginAllowThreads();
50940 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50941 wxPyEndAllowThreads(__tstate);
50942 if (PyErr_Occurred()) SWIG_fail;
50943 }
50944 {
50945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50946 }
50947 return resultobj;
50948 fail:
50949 return NULL;
50950 }
50951
50952
50953 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50954 PyObject *resultobj = 0;
50955 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50956 wxGBSizerItem *arg2 = 0 ;
50957 bool result;
50958 void *argp1 = 0 ;
50959 int res1 = 0 ;
50960 void *argp2 = 0 ;
50961 int res2 = 0 ;
50962 PyObject * obj0 = 0 ;
50963 PyObject * obj1 = 0 ;
50964 char * kwnames[] = {
50965 (char *) "self",(char *) "other", NULL
50966 };
50967
50968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50970 if (!SWIG_IsOK(res1)) {
50971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50972 }
50973 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50974 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50975 if (!SWIG_IsOK(res2)) {
50976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50977 }
50978 if (!argp2) {
50979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50980 }
50981 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50982 {
50983 PyThreadState* __tstate = wxPyBeginAllowThreads();
50984 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50985 wxPyEndAllowThreads(__tstate);
50986 if (PyErr_Occurred()) SWIG_fail;
50987 }
50988 {
50989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50990 }
50991 return resultobj;
50992 fail:
50993 return NULL;
50994 }
50995
50996
50997 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50998 PyObject *resultobj = 0;
50999 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51000 wxGBPosition *arg2 = 0 ;
51001 wxGBSpan *arg3 = 0 ;
51002 bool result;
51003 void *argp1 = 0 ;
51004 int res1 = 0 ;
51005 wxGBPosition temp2 ;
51006 wxGBSpan temp3 ;
51007 PyObject * obj0 = 0 ;
51008 PyObject * obj1 = 0 ;
51009 PyObject * obj2 = 0 ;
51010 char * kwnames[] = {
51011 (char *) "self",(char *) "pos",(char *) "span", NULL
51012 };
51013
51014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51016 if (!SWIG_IsOK(res1)) {
51017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51018 }
51019 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51020 {
51021 arg2 = &temp2;
51022 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51023 }
51024 {
51025 arg3 = &temp3;
51026 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51027 }
51028 {
51029 PyThreadState* __tstate = wxPyBeginAllowThreads();
51030 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51031 wxPyEndAllowThreads(__tstate);
51032 if (PyErr_Occurred()) SWIG_fail;
51033 }
51034 {
51035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51036 }
51037 return resultobj;
51038 fail:
51039 return NULL;
51040 }
51041
51042
51043 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51044 PyObject *resultobj = 0;
51045 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51046 wxGBPosition result;
51047 void *argp1 = 0 ;
51048 int res1 = 0 ;
51049 PyObject *swig_obj[1] ;
51050
51051 if (!args) SWIG_fail;
51052 swig_obj[0] = args;
51053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51054 if (!SWIG_IsOK(res1)) {
51055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51056 }
51057 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51058 {
51059 PyThreadState* __tstate = wxPyBeginAllowThreads();
51060 result = wxGBSizerItem_GetEndPos(arg1);
51061 wxPyEndAllowThreads(__tstate);
51062 if (PyErr_Occurred()) SWIG_fail;
51063 }
51064 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51065 return resultobj;
51066 fail:
51067 return NULL;
51068 }
51069
51070
51071 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51072 PyObject *resultobj = 0;
51073 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51074 wxGridBagSizer *result = 0 ;
51075 void *argp1 = 0 ;
51076 int res1 = 0 ;
51077 PyObject *swig_obj[1] ;
51078
51079 if (!args) SWIG_fail;
51080 swig_obj[0] = args;
51081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51082 if (!SWIG_IsOK(res1)) {
51083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51084 }
51085 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51086 {
51087 PyThreadState* __tstate = wxPyBeginAllowThreads();
51088 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51089 wxPyEndAllowThreads(__tstate);
51090 if (PyErr_Occurred()) SWIG_fail;
51091 }
51092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51093 return resultobj;
51094 fail:
51095 return NULL;
51096 }
51097
51098
51099 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51100 PyObject *resultobj = 0;
51101 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51102 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51103 void *argp1 = 0 ;
51104 int res1 = 0 ;
51105 void *argp2 = 0 ;
51106 int res2 = 0 ;
51107 PyObject * obj0 = 0 ;
51108 PyObject * obj1 = 0 ;
51109 char * kwnames[] = {
51110 (char *) "self",(char *) "sizer", NULL
51111 };
51112
51113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51115 if (!SWIG_IsOK(res1)) {
51116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51117 }
51118 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51119 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51120 if (!SWIG_IsOK(res2)) {
51121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51122 }
51123 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51124 {
51125 PyThreadState* __tstate = wxPyBeginAllowThreads();
51126 (arg1)->SetGBSizer(arg2);
51127 wxPyEndAllowThreads(__tstate);
51128 if (PyErr_Occurred()) SWIG_fail;
51129 }
51130 resultobj = SWIG_Py_Void();
51131 return resultobj;
51132 fail:
51133 return NULL;
51134 }
51135
51136
51137 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51138 PyObject *obj;
51139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51140 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51141 return SWIG_Py_Void();
51142 }
51143
51144 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51145 return SWIG_Python_InitShadowInstance(args);
51146 }
51147
51148 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51149 PyObject *resultobj = 0;
51150 int arg1 = (int) 0 ;
51151 int arg2 = (int) 0 ;
51152 wxGridBagSizer *result = 0 ;
51153 int val1 ;
51154 int ecode1 = 0 ;
51155 int val2 ;
51156 int ecode2 = 0 ;
51157 PyObject * obj0 = 0 ;
51158 PyObject * obj1 = 0 ;
51159 char * kwnames[] = {
51160 (char *) "vgap",(char *) "hgap", NULL
51161 };
51162
51163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51164 if (obj0) {
51165 ecode1 = SWIG_AsVal_int(obj0, &val1);
51166 if (!SWIG_IsOK(ecode1)) {
51167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51168 }
51169 arg1 = static_cast< int >(val1);
51170 }
51171 if (obj1) {
51172 ecode2 = SWIG_AsVal_int(obj1, &val2);
51173 if (!SWIG_IsOK(ecode2)) {
51174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51175 }
51176 arg2 = static_cast< int >(val2);
51177 }
51178 {
51179 PyThreadState* __tstate = wxPyBeginAllowThreads();
51180 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51181 wxPyEndAllowThreads(__tstate);
51182 if (PyErr_Occurred()) SWIG_fail;
51183 }
51184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51185 return resultobj;
51186 fail:
51187 return NULL;
51188 }
51189
51190
51191 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51192 PyObject *resultobj = 0;
51193 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51194 PyObject *arg2 = (PyObject *) 0 ;
51195 wxGBPosition *arg3 = 0 ;
51196 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51197 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51198 int arg5 = (int) 0 ;
51199 int arg6 = (int) 0 ;
51200 PyObject *arg7 = (PyObject *) NULL ;
51201 wxGBSizerItem *result = 0 ;
51202 void *argp1 = 0 ;
51203 int res1 = 0 ;
51204 wxGBPosition temp3 ;
51205 wxGBSpan temp4 ;
51206 int val5 ;
51207 int ecode5 = 0 ;
51208 int val6 ;
51209 int ecode6 = 0 ;
51210 PyObject * obj0 = 0 ;
51211 PyObject * obj1 = 0 ;
51212 PyObject * obj2 = 0 ;
51213 PyObject * obj3 = 0 ;
51214 PyObject * obj4 = 0 ;
51215 PyObject * obj5 = 0 ;
51216 PyObject * obj6 = 0 ;
51217 char * kwnames[] = {
51218 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51219 };
51220
51221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51223 if (!SWIG_IsOK(res1)) {
51224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51225 }
51226 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51227 arg2 = obj1;
51228 {
51229 arg3 = &temp3;
51230 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51231 }
51232 if (obj3) {
51233 {
51234 arg4 = &temp4;
51235 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51236 }
51237 }
51238 if (obj4) {
51239 ecode5 = SWIG_AsVal_int(obj4, &val5);
51240 if (!SWIG_IsOK(ecode5)) {
51241 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51242 }
51243 arg5 = static_cast< int >(val5);
51244 }
51245 if (obj5) {
51246 ecode6 = SWIG_AsVal_int(obj5, &val6);
51247 if (!SWIG_IsOK(ecode6)) {
51248 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51249 }
51250 arg6 = static_cast< int >(val6);
51251 }
51252 if (obj6) {
51253 arg7 = obj6;
51254 }
51255 {
51256 PyThreadState* __tstate = wxPyBeginAllowThreads();
51257 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51258 wxPyEndAllowThreads(__tstate);
51259 if (PyErr_Occurred()) SWIG_fail;
51260 }
51261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51262 return resultobj;
51263 fail:
51264 return NULL;
51265 }
51266
51267
51268 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51269 PyObject *resultobj = 0;
51270 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51271 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51272 wxGBSizerItem *result = 0 ;
51273 void *argp1 = 0 ;
51274 int res1 = 0 ;
51275 int res2 = 0 ;
51276 PyObject * obj0 = 0 ;
51277 PyObject * obj1 = 0 ;
51278 char * kwnames[] = {
51279 (char *) "self",(char *) "item", NULL
51280 };
51281
51282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51284 if (!SWIG_IsOK(res1)) {
51285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51286 }
51287 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51288 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51289 if (!SWIG_IsOK(res2)) {
51290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51291 }
51292 {
51293 PyThreadState* __tstate = wxPyBeginAllowThreads();
51294 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51295 wxPyEndAllowThreads(__tstate);
51296 if (PyErr_Occurred()) SWIG_fail;
51297 }
51298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51299 return resultobj;
51300 fail:
51301 return NULL;
51302 }
51303
51304
51305 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51306 PyObject *resultobj = 0;
51307 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51308 int arg2 ;
51309 int arg3 ;
51310 wxSize result;
51311 void *argp1 = 0 ;
51312 int res1 = 0 ;
51313 int val2 ;
51314 int ecode2 = 0 ;
51315 int val3 ;
51316 int ecode3 = 0 ;
51317 PyObject * obj0 = 0 ;
51318 PyObject * obj1 = 0 ;
51319 PyObject * obj2 = 0 ;
51320 char * kwnames[] = {
51321 (char *) "self",(char *) "row",(char *) "col", NULL
51322 };
51323
51324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51326 if (!SWIG_IsOK(res1)) {
51327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51328 }
51329 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51330 ecode2 = SWIG_AsVal_int(obj1, &val2);
51331 if (!SWIG_IsOK(ecode2)) {
51332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51333 }
51334 arg2 = static_cast< int >(val2);
51335 ecode3 = SWIG_AsVal_int(obj2, &val3);
51336 if (!SWIG_IsOK(ecode3)) {
51337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51338 }
51339 arg3 = static_cast< int >(val3);
51340 {
51341 PyThreadState* __tstate = wxPyBeginAllowThreads();
51342 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51343 wxPyEndAllowThreads(__tstate);
51344 if (PyErr_Occurred()) SWIG_fail;
51345 }
51346 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51347 return resultobj;
51348 fail:
51349 return NULL;
51350 }
51351
51352
51353 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51354 PyObject *resultobj = 0;
51355 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51356 wxSize result;
51357 void *argp1 = 0 ;
51358 int res1 = 0 ;
51359 PyObject *swig_obj[1] ;
51360
51361 if (!args) SWIG_fail;
51362 swig_obj[0] = args;
51363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51364 if (!SWIG_IsOK(res1)) {
51365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51366 }
51367 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51368 {
51369 PyThreadState* __tstate = wxPyBeginAllowThreads();
51370 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51371 wxPyEndAllowThreads(__tstate);
51372 if (PyErr_Occurred()) SWIG_fail;
51373 }
51374 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51375 return resultobj;
51376 fail:
51377 return NULL;
51378 }
51379
51380
51381 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51382 PyObject *resultobj = 0;
51383 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51384 wxSize *arg2 = 0 ;
51385 void *argp1 = 0 ;
51386 int res1 = 0 ;
51387 wxSize temp2 ;
51388 PyObject * obj0 = 0 ;
51389 PyObject * obj1 = 0 ;
51390 char * kwnames[] = {
51391 (char *) "self",(char *) "sz", NULL
51392 };
51393
51394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51396 if (!SWIG_IsOK(res1)) {
51397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51398 }
51399 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51400 {
51401 arg2 = &temp2;
51402 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51403 }
51404 {
51405 PyThreadState* __tstate = wxPyBeginAllowThreads();
51406 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51407 wxPyEndAllowThreads(__tstate);
51408 if (PyErr_Occurred()) SWIG_fail;
51409 }
51410 resultobj = SWIG_Py_Void();
51411 return resultobj;
51412 fail:
51413 return NULL;
51414 }
51415
51416
51417 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51418 PyObject *resultobj = 0;
51419 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51420 wxWindow *arg2 = (wxWindow *) 0 ;
51421 wxGBPosition result;
51422 void *argp1 = 0 ;
51423 int res1 = 0 ;
51424 void *argp2 = 0 ;
51425 int res2 = 0 ;
51426
51427 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51429 if (!SWIG_IsOK(res1)) {
51430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51431 }
51432 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51433 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51434 if (!SWIG_IsOK(res2)) {
51435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51436 }
51437 arg2 = reinterpret_cast< wxWindow * >(argp2);
51438 {
51439 PyThreadState* __tstate = wxPyBeginAllowThreads();
51440 result = (arg1)->GetItemPosition(arg2);
51441 wxPyEndAllowThreads(__tstate);
51442 if (PyErr_Occurred()) SWIG_fail;
51443 }
51444 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51445 return resultobj;
51446 fail:
51447 return NULL;
51448 }
51449
51450
51451 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51452 PyObject *resultobj = 0;
51453 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51454 wxSizer *arg2 = (wxSizer *) 0 ;
51455 wxGBPosition result;
51456 void *argp1 = 0 ;
51457 int res1 = 0 ;
51458 void *argp2 = 0 ;
51459 int res2 = 0 ;
51460
51461 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51463 if (!SWIG_IsOK(res1)) {
51464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51465 }
51466 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51467 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51468 if (!SWIG_IsOK(res2)) {
51469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51470 }
51471 arg2 = reinterpret_cast< wxSizer * >(argp2);
51472 {
51473 PyThreadState* __tstate = wxPyBeginAllowThreads();
51474 result = (arg1)->GetItemPosition(arg2);
51475 wxPyEndAllowThreads(__tstate);
51476 if (PyErr_Occurred()) SWIG_fail;
51477 }
51478 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51479 return resultobj;
51480 fail:
51481 return NULL;
51482 }
51483
51484
51485 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51486 PyObject *resultobj = 0;
51487 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51488 size_t arg2 ;
51489 wxGBPosition result;
51490 void *argp1 = 0 ;
51491 int res1 = 0 ;
51492 size_t val2 ;
51493 int ecode2 = 0 ;
51494
51495 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51497 if (!SWIG_IsOK(res1)) {
51498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51499 }
51500 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51501 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51502 if (!SWIG_IsOK(ecode2)) {
51503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51504 }
51505 arg2 = static_cast< size_t >(val2);
51506 {
51507 PyThreadState* __tstate = wxPyBeginAllowThreads();
51508 result = (arg1)->GetItemPosition(arg2);
51509 wxPyEndAllowThreads(__tstate);
51510 if (PyErr_Occurred()) SWIG_fail;
51511 }
51512 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51513 return resultobj;
51514 fail:
51515 return NULL;
51516 }
51517
51518
51519 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51520 int argc;
51521 PyObject *argv[3];
51522
51523 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51524 --argc;
51525 if (argc == 2) {
51526 int _v = 0;
51527 {
51528 void *vptr = 0;
51529 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51530 _v = SWIG_CheckState(res);
51531 }
51532 if (!_v) goto check_1;
51533 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51534 }
51535 check_1:
51536
51537 if (argc == 2) {
51538 int _v = 0;
51539 {
51540 void *vptr = 0;
51541 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51542 _v = SWIG_CheckState(res);
51543 }
51544 if (!_v) goto check_2;
51545 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51546 }
51547 check_2:
51548
51549 if (argc == 2) {
51550 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51551 }
51552
51553 fail:
51554 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51555 return NULL;
51556 }
51557
51558
51559 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51560 PyObject *resultobj = 0;
51561 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51562 wxWindow *arg2 = (wxWindow *) 0 ;
51563 wxGBPosition *arg3 = 0 ;
51564 bool result;
51565 void *argp1 = 0 ;
51566 int res1 = 0 ;
51567 void *argp2 = 0 ;
51568 int res2 = 0 ;
51569 wxGBPosition temp3 ;
51570
51571 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51573 if (!SWIG_IsOK(res1)) {
51574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51575 }
51576 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51577 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51578 if (!SWIG_IsOK(res2)) {
51579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51580 }
51581 arg2 = reinterpret_cast< wxWindow * >(argp2);
51582 {
51583 arg3 = &temp3;
51584 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51585 }
51586 {
51587 PyThreadState* __tstate = wxPyBeginAllowThreads();
51588 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51589 wxPyEndAllowThreads(__tstate);
51590 if (PyErr_Occurred()) SWIG_fail;
51591 }
51592 {
51593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51594 }
51595 return resultobj;
51596 fail:
51597 return NULL;
51598 }
51599
51600
51601 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51602 PyObject *resultobj = 0;
51603 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51604 wxSizer *arg2 = (wxSizer *) 0 ;
51605 wxGBPosition *arg3 = 0 ;
51606 bool result;
51607 void *argp1 = 0 ;
51608 int res1 = 0 ;
51609 void *argp2 = 0 ;
51610 int res2 = 0 ;
51611 wxGBPosition temp3 ;
51612
51613 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51615 if (!SWIG_IsOK(res1)) {
51616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51617 }
51618 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51619 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51620 if (!SWIG_IsOK(res2)) {
51621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51622 }
51623 arg2 = reinterpret_cast< wxSizer * >(argp2);
51624 {
51625 arg3 = &temp3;
51626 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51627 }
51628 {
51629 PyThreadState* __tstate = wxPyBeginAllowThreads();
51630 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51631 wxPyEndAllowThreads(__tstate);
51632 if (PyErr_Occurred()) SWIG_fail;
51633 }
51634 {
51635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51636 }
51637 return resultobj;
51638 fail:
51639 return NULL;
51640 }
51641
51642
51643 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51644 PyObject *resultobj = 0;
51645 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51646 size_t arg2 ;
51647 wxGBPosition *arg3 = 0 ;
51648 bool result;
51649 void *argp1 = 0 ;
51650 int res1 = 0 ;
51651 size_t val2 ;
51652 int ecode2 = 0 ;
51653 wxGBPosition temp3 ;
51654
51655 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51657 if (!SWIG_IsOK(res1)) {
51658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51659 }
51660 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51661 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51662 if (!SWIG_IsOK(ecode2)) {
51663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51664 }
51665 arg2 = static_cast< size_t >(val2);
51666 {
51667 arg3 = &temp3;
51668 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51669 }
51670 {
51671 PyThreadState* __tstate = wxPyBeginAllowThreads();
51672 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51673 wxPyEndAllowThreads(__tstate);
51674 if (PyErr_Occurred()) SWIG_fail;
51675 }
51676 {
51677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51678 }
51679 return resultobj;
51680 fail:
51681 return NULL;
51682 }
51683
51684
51685 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51686 int argc;
51687 PyObject *argv[4];
51688
51689 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51690 --argc;
51691 if (argc == 3) {
51692 int _v = 0;
51693 {
51694 void *vptr = 0;
51695 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51696 _v = SWIG_CheckState(res);
51697 }
51698 if (!_v) goto check_1;
51699 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51700 }
51701 check_1:
51702
51703 if (argc == 3) {
51704 int _v = 0;
51705 {
51706 void *vptr = 0;
51707 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51708 _v = SWIG_CheckState(res);
51709 }
51710 if (!_v) goto check_2;
51711 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51712 }
51713 check_2:
51714
51715 if (argc == 3) {
51716 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51717 }
51718
51719 fail:
51720 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51721 return NULL;
51722 }
51723
51724
51725 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51726 PyObject *resultobj = 0;
51727 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51728 wxWindow *arg2 = (wxWindow *) 0 ;
51729 wxGBSpan result;
51730 void *argp1 = 0 ;
51731 int res1 = 0 ;
51732 void *argp2 = 0 ;
51733 int res2 = 0 ;
51734
51735 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51737 if (!SWIG_IsOK(res1)) {
51738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51739 }
51740 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51741 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51742 if (!SWIG_IsOK(res2)) {
51743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51744 }
51745 arg2 = reinterpret_cast< wxWindow * >(argp2);
51746 {
51747 PyThreadState* __tstate = wxPyBeginAllowThreads();
51748 result = (arg1)->GetItemSpan(arg2);
51749 wxPyEndAllowThreads(__tstate);
51750 if (PyErr_Occurred()) SWIG_fail;
51751 }
51752 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51753 return resultobj;
51754 fail:
51755 return NULL;
51756 }
51757
51758
51759 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51760 PyObject *resultobj = 0;
51761 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51762 wxSizer *arg2 = (wxSizer *) 0 ;
51763 wxGBSpan result;
51764 void *argp1 = 0 ;
51765 int res1 = 0 ;
51766 void *argp2 = 0 ;
51767 int res2 = 0 ;
51768
51769 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51771 if (!SWIG_IsOK(res1)) {
51772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51773 }
51774 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51775 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51776 if (!SWIG_IsOK(res2)) {
51777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51778 }
51779 arg2 = reinterpret_cast< wxSizer * >(argp2);
51780 {
51781 PyThreadState* __tstate = wxPyBeginAllowThreads();
51782 result = (arg1)->GetItemSpan(arg2);
51783 wxPyEndAllowThreads(__tstate);
51784 if (PyErr_Occurred()) SWIG_fail;
51785 }
51786 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51787 return resultobj;
51788 fail:
51789 return NULL;
51790 }
51791
51792
51793 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51794 PyObject *resultobj = 0;
51795 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51796 size_t arg2 ;
51797 wxGBSpan result;
51798 void *argp1 = 0 ;
51799 int res1 = 0 ;
51800 size_t val2 ;
51801 int ecode2 = 0 ;
51802
51803 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51805 if (!SWIG_IsOK(res1)) {
51806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51807 }
51808 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51809 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51810 if (!SWIG_IsOK(ecode2)) {
51811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51812 }
51813 arg2 = static_cast< size_t >(val2);
51814 {
51815 PyThreadState* __tstate = wxPyBeginAllowThreads();
51816 result = (arg1)->GetItemSpan(arg2);
51817 wxPyEndAllowThreads(__tstate);
51818 if (PyErr_Occurred()) SWIG_fail;
51819 }
51820 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51821 return resultobj;
51822 fail:
51823 return NULL;
51824 }
51825
51826
51827 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51828 int argc;
51829 PyObject *argv[3];
51830
51831 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51832 --argc;
51833 if (argc == 2) {
51834 int _v = 0;
51835 {
51836 void *vptr = 0;
51837 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51838 _v = SWIG_CheckState(res);
51839 }
51840 if (!_v) goto check_1;
51841 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51842 }
51843 check_1:
51844
51845 if (argc == 2) {
51846 int _v = 0;
51847 {
51848 void *vptr = 0;
51849 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51850 _v = SWIG_CheckState(res);
51851 }
51852 if (!_v) goto check_2;
51853 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51854 }
51855 check_2:
51856
51857 if (argc == 2) {
51858 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51859 }
51860
51861 fail:
51862 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51863 return NULL;
51864 }
51865
51866
51867 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51868 PyObject *resultobj = 0;
51869 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51870 wxWindow *arg2 = (wxWindow *) 0 ;
51871 wxGBSpan *arg3 = 0 ;
51872 bool result;
51873 void *argp1 = 0 ;
51874 int res1 = 0 ;
51875 void *argp2 = 0 ;
51876 int res2 = 0 ;
51877 wxGBSpan temp3 ;
51878
51879 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51881 if (!SWIG_IsOK(res1)) {
51882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51883 }
51884 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51885 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51886 if (!SWIG_IsOK(res2)) {
51887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51888 }
51889 arg2 = reinterpret_cast< wxWindow * >(argp2);
51890 {
51891 arg3 = &temp3;
51892 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51893 }
51894 {
51895 PyThreadState* __tstate = wxPyBeginAllowThreads();
51896 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51897 wxPyEndAllowThreads(__tstate);
51898 if (PyErr_Occurred()) SWIG_fail;
51899 }
51900 {
51901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51902 }
51903 return resultobj;
51904 fail:
51905 return NULL;
51906 }
51907
51908
51909 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51910 PyObject *resultobj = 0;
51911 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51912 wxSizer *arg2 = (wxSizer *) 0 ;
51913 wxGBSpan *arg3 = 0 ;
51914 bool result;
51915 void *argp1 = 0 ;
51916 int res1 = 0 ;
51917 void *argp2 = 0 ;
51918 int res2 = 0 ;
51919 wxGBSpan temp3 ;
51920
51921 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51923 if (!SWIG_IsOK(res1)) {
51924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51925 }
51926 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51927 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51928 if (!SWIG_IsOK(res2)) {
51929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51930 }
51931 arg2 = reinterpret_cast< wxSizer * >(argp2);
51932 {
51933 arg3 = &temp3;
51934 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51935 }
51936 {
51937 PyThreadState* __tstate = wxPyBeginAllowThreads();
51938 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51939 wxPyEndAllowThreads(__tstate);
51940 if (PyErr_Occurred()) SWIG_fail;
51941 }
51942 {
51943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51944 }
51945 return resultobj;
51946 fail:
51947 return NULL;
51948 }
51949
51950
51951 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51952 PyObject *resultobj = 0;
51953 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51954 size_t arg2 ;
51955 wxGBSpan *arg3 = 0 ;
51956 bool result;
51957 void *argp1 = 0 ;
51958 int res1 = 0 ;
51959 size_t val2 ;
51960 int ecode2 = 0 ;
51961 wxGBSpan temp3 ;
51962
51963 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51965 if (!SWIG_IsOK(res1)) {
51966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51967 }
51968 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51969 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51970 if (!SWIG_IsOK(ecode2)) {
51971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51972 }
51973 arg2 = static_cast< size_t >(val2);
51974 {
51975 arg3 = &temp3;
51976 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51977 }
51978 {
51979 PyThreadState* __tstate = wxPyBeginAllowThreads();
51980 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51981 wxPyEndAllowThreads(__tstate);
51982 if (PyErr_Occurred()) SWIG_fail;
51983 }
51984 {
51985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51986 }
51987 return resultobj;
51988 fail:
51989 return NULL;
51990 }
51991
51992
51993 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51994 int argc;
51995 PyObject *argv[4];
51996
51997 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51998 --argc;
51999 if (argc == 3) {
52000 int _v = 0;
52001 {
52002 void *vptr = 0;
52003 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52004 _v = SWIG_CheckState(res);
52005 }
52006 if (!_v) goto check_1;
52007 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52008 }
52009 check_1:
52010
52011 if (argc == 3) {
52012 int _v = 0;
52013 {
52014 void *vptr = 0;
52015 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52016 _v = SWIG_CheckState(res);
52017 }
52018 if (!_v) goto check_2;
52019 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52020 }
52021 check_2:
52022
52023 if (argc == 3) {
52024 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52025 }
52026
52027 fail:
52028 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52029 return NULL;
52030 }
52031
52032
52033 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52034 PyObject *resultobj = 0;
52035 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52036 wxWindow *arg2 = (wxWindow *) 0 ;
52037 wxGBSizerItem *result = 0 ;
52038 void *argp1 = 0 ;
52039 int res1 = 0 ;
52040 void *argp2 = 0 ;
52041 int res2 = 0 ;
52042
52043 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52045 if (!SWIG_IsOK(res1)) {
52046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52047 }
52048 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52049 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52050 if (!SWIG_IsOK(res2)) {
52051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52052 }
52053 arg2 = reinterpret_cast< wxWindow * >(argp2);
52054 {
52055 PyThreadState* __tstate = wxPyBeginAllowThreads();
52056 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52057 wxPyEndAllowThreads(__tstate);
52058 if (PyErr_Occurred()) SWIG_fail;
52059 }
52060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52061 return resultobj;
52062 fail:
52063 return NULL;
52064 }
52065
52066
52067 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52068 PyObject *resultobj = 0;
52069 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52070 wxSizer *arg2 = (wxSizer *) 0 ;
52071 wxGBSizerItem *result = 0 ;
52072 void *argp1 = 0 ;
52073 int res1 = 0 ;
52074 void *argp2 = 0 ;
52075 int res2 = 0 ;
52076
52077 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52079 if (!SWIG_IsOK(res1)) {
52080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52081 }
52082 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52083 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52084 if (!SWIG_IsOK(res2)) {
52085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52086 }
52087 arg2 = reinterpret_cast< wxSizer * >(argp2);
52088 {
52089 PyThreadState* __tstate = wxPyBeginAllowThreads();
52090 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52091 wxPyEndAllowThreads(__tstate);
52092 if (PyErr_Occurred()) SWIG_fail;
52093 }
52094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52095 return resultobj;
52096 fail:
52097 return NULL;
52098 }
52099
52100
52101 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52102 int argc;
52103 PyObject *argv[3];
52104
52105 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52106 --argc;
52107 if (argc == 2) {
52108 int _v = 0;
52109 {
52110 void *vptr = 0;
52111 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52112 _v = SWIG_CheckState(res);
52113 }
52114 if (!_v) goto check_1;
52115 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52116 }
52117 check_1:
52118
52119 if (argc == 2) {
52120 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52121 }
52122
52123 fail:
52124 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52125 return NULL;
52126 }
52127
52128
52129 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52130 PyObject *resultobj = 0;
52131 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52132 wxGBPosition *arg2 = 0 ;
52133 wxGBSizerItem *result = 0 ;
52134 void *argp1 = 0 ;
52135 int res1 = 0 ;
52136 wxGBPosition temp2 ;
52137 PyObject * obj0 = 0 ;
52138 PyObject * obj1 = 0 ;
52139 char * kwnames[] = {
52140 (char *) "self",(char *) "pos", NULL
52141 };
52142
52143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52145 if (!SWIG_IsOK(res1)) {
52146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52147 }
52148 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52149 {
52150 arg2 = &temp2;
52151 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52152 }
52153 {
52154 PyThreadState* __tstate = wxPyBeginAllowThreads();
52155 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52156 wxPyEndAllowThreads(__tstate);
52157 if (PyErr_Occurred()) SWIG_fail;
52158 }
52159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52160 return resultobj;
52161 fail:
52162 return NULL;
52163 }
52164
52165
52166 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52167 PyObject *resultobj = 0;
52168 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52169 wxPoint *arg2 = 0 ;
52170 wxGBSizerItem *result = 0 ;
52171 void *argp1 = 0 ;
52172 int res1 = 0 ;
52173 wxPoint temp2 ;
52174 PyObject * obj0 = 0 ;
52175 PyObject * obj1 = 0 ;
52176 char * kwnames[] = {
52177 (char *) "self",(char *) "pt", NULL
52178 };
52179
52180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52182 if (!SWIG_IsOK(res1)) {
52183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52184 }
52185 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52186 {
52187 arg2 = &temp2;
52188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52189 }
52190 {
52191 PyThreadState* __tstate = wxPyBeginAllowThreads();
52192 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52193 wxPyEndAllowThreads(__tstate);
52194 if (PyErr_Occurred()) SWIG_fail;
52195 }
52196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52197 return resultobj;
52198 fail:
52199 return NULL;
52200 }
52201
52202
52203 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52204 PyObject *resultobj = 0;
52205 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52206 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52207 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52208 bool result;
52209 void *argp1 = 0 ;
52210 int res1 = 0 ;
52211 void *argp2 = 0 ;
52212 int res2 = 0 ;
52213 void *argp3 = 0 ;
52214 int res3 = 0 ;
52215 PyObject * obj0 = 0 ;
52216 PyObject * obj1 = 0 ;
52217 PyObject * obj2 = 0 ;
52218 char * kwnames[] = {
52219 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52220 };
52221
52222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52224 if (!SWIG_IsOK(res1)) {
52225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52226 }
52227 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52229 if (!SWIG_IsOK(res2)) {
52230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52231 }
52232 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52233 if (obj2) {
52234 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52235 if (!SWIG_IsOK(res3)) {
52236 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52237 }
52238 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52239 }
52240 {
52241 PyThreadState* __tstate = wxPyBeginAllowThreads();
52242 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52243 wxPyEndAllowThreads(__tstate);
52244 if (PyErr_Occurred()) SWIG_fail;
52245 }
52246 {
52247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52248 }
52249 return resultobj;
52250 fail:
52251 return NULL;
52252 }
52253
52254
52255 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52256 PyObject *resultobj = 0;
52257 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52258 wxGBPosition *arg2 = 0 ;
52259 wxGBSpan *arg3 = 0 ;
52260 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52261 bool result;
52262 void *argp1 = 0 ;
52263 int res1 = 0 ;
52264 wxGBPosition temp2 ;
52265 wxGBSpan temp3 ;
52266 void *argp4 = 0 ;
52267 int res4 = 0 ;
52268 PyObject * obj0 = 0 ;
52269 PyObject * obj1 = 0 ;
52270 PyObject * obj2 = 0 ;
52271 PyObject * obj3 = 0 ;
52272 char * kwnames[] = {
52273 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52274 };
52275
52276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52278 if (!SWIG_IsOK(res1)) {
52279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52280 }
52281 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52282 {
52283 arg2 = &temp2;
52284 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52285 }
52286 {
52287 arg3 = &temp3;
52288 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52289 }
52290 if (obj3) {
52291 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52292 if (!SWIG_IsOK(res4)) {
52293 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52294 }
52295 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52296 }
52297 {
52298 PyThreadState* __tstate = wxPyBeginAllowThreads();
52299 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52300 wxPyEndAllowThreads(__tstate);
52301 if (PyErr_Occurred()) SWIG_fail;
52302 }
52303 {
52304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52305 }
52306 return resultobj;
52307 fail:
52308 return NULL;
52309 }
52310
52311
52312 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52313 PyObject *obj;
52314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52315 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52316 return SWIG_Py_Void();
52317 }
52318
52319 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52320 return SWIG_Python_InitShadowInstance(args);
52321 }
52322
52323 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52324 PyObject *resultobj = 0;
52325 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52326 wxRelationship arg2 ;
52327 wxWindow *arg3 = (wxWindow *) 0 ;
52328 wxEdge arg4 ;
52329 int arg5 = (int) 0 ;
52330 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52331 void *argp1 = 0 ;
52332 int res1 = 0 ;
52333 int val2 ;
52334 int ecode2 = 0 ;
52335 void *argp3 = 0 ;
52336 int res3 = 0 ;
52337 int val4 ;
52338 int ecode4 = 0 ;
52339 int val5 ;
52340 int ecode5 = 0 ;
52341 int val6 ;
52342 int ecode6 = 0 ;
52343 PyObject * obj0 = 0 ;
52344 PyObject * obj1 = 0 ;
52345 PyObject * obj2 = 0 ;
52346 PyObject * obj3 = 0 ;
52347 PyObject * obj4 = 0 ;
52348 PyObject * obj5 = 0 ;
52349 char * kwnames[] = {
52350 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52351 };
52352
52353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52355 if (!SWIG_IsOK(res1)) {
52356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52357 }
52358 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52359 ecode2 = SWIG_AsVal_int(obj1, &val2);
52360 if (!SWIG_IsOK(ecode2)) {
52361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52362 }
52363 arg2 = static_cast< wxRelationship >(val2);
52364 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52365 if (!SWIG_IsOK(res3)) {
52366 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52367 }
52368 arg3 = reinterpret_cast< wxWindow * >(argp3);
52369 ecode4 = SWIG_AsVal_int(obj3, &val4);
52370 if (!SWIG_IsOK(ecode4)) {
52371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52372 }
52373 arg4 = static_cast< wxEdge >(val4);
52374 if (obj4) {
52375 ecode5 = SWIG_AsVal_int(obj4, &val5);
52376 if (!SWIG_IsOK(ecode5)) {
52377 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52378 }
52379 arg5 = static_cast< int >(val5);
52380 }
52381 if (obj5) {
52382 ecode6 = SWIG_AsVal_int(obj5, &val6);
52383 if (!SWIG_IsOK(ecode6)) {
52384 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52385 }
52386 arg6 = static_cast< int >(val6);
52387 }
52388 {
52389 PyThreadState* __tstate = wxPyBeginAllowThreads();
52390 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52391 wxPyEndAllowThreads(__tstate);
52392 if (PyErr_Occurred()) SWIG_fail;
52393 }
52394 resultobj = SWIG_Py_Void();
52395 return resultobj;
52396 fail:
52397 return NULL;
52398 }
52399
52400
52401 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52402 PyObject *resultobj = 0;
52403 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52404 wxWindow *arg2 = (wxWindow *) 0 ;
52405 int arg3 = (int) 0 ;
52406 void *argp1 = 0 ;
52407 int res1 = 0 ;
52408 void *argp2 = 0 ;
52409 int res2 = 0 ;
52410 int val3 ;
52411 int ecode3 = 0 ;
52412 PyObject * obj0 = 0 ;
52413 PyObject * obj1 = 0 ;
52414 PyObject * obj2 = 0 ;
52415 char * kwnames[] = {
52416 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52417 };
52418
52419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52421 if (!SWIG_IsOK(res1)) {
52422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52423 }
52424 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52426 if (!SWIG_IsOK(res2)) {
52427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52428 }
52429 arg2 = reinterpret_cast< wxWindow * >(argp2);
52430 if (obj2) {
52431 ecode3 = SWIG_AsVal_int(obj2, &val3);
52432 if (!SWIG_IsOK(ecode3)) {
52433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52434 }
52435 arg3 = static_cast< int >(val3);
52436 }
52437 {
52438 PyThreadState* __tstate = wxPyBeginAllowThreads();
52439 (arg1)->LeftOf(arg2,arg3);
52440 wxPyEndAllowThreads(__tstate);
52441 if (PyErr_Occurred()) SWIG_fail;
52442 }
52443 resultobj = SWIG_Py_Void();
52444 return resultobj;
52445 fail:
52446 return NULL;
52447 }
52448
52449
52450 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52451 PyObject *resultobj = 0;
52452 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52453 wxWindow *arg2 = (wxWindow *) 0 ;
52454 int arg3 = (int) 0 ;
52455 void *argp1 = 0 ;
52456 int res1 = 0 ;
52457 void *argp2 = 0 ;
52458 int res2 = 0 ;
52459 int val3 ;
52460 int ecode3 = 0 ;
52461 PyObject * obj0 = 0 ;
52462 PyObject * obj1 = 0 ;
52463 PyObject * obj2 = 0 ;
52464 char * kwnames[] = {
52465 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52466 };
52467
52468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52470 if (!SWIG_IsOK(res1)) {
52471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52472 }
52473 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52474 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52475 if (!SWIG_IsOK(res2)) {
52476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52477 }
52478 arg2 = reinterpret_cast< wxWindow * >(argp2);
52479 if (obj2) {
52480 ecode3 = SWIG_AsVal_int(obj2, &val3);
52481 if (!SWIG_IsOK(ecode3)) {
52482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52483 }
52484 arg3 = static_cast< int >(val3);
52485 }
52486 {
52487 PyThreadState* __tstate = wxPyBeginAllowThreads();
52488 (arg1)->RightOf(arg2,arg3);
52489 wxPyEndAllowThreads(__tstate);
52490 if (PyErr_Occurred()) SWIG_fail;
52491 }
52492 resultobj = SWIG_Py_Void();
52493 return resultobj;
52494 fail:
52495 return NULL;
52496 }
52497
52498
52499 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52500 PyObject *resultobj = 0;
52501 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52502 wxWindow *arg2 = (wxWindow *) 0 ;
52503 int arg3 = (int) 0 ;
52504 void *argp1 = 0 ;
52505 int res1 = 0 ;
52506 void *argp2 = 0 ;
52507 int res2 = 0 ;
52508 int val3 ;
52509 int ecode3 = 0 ;
52510 PyObject * obj0 = 0 ;
52511 PyObject * obj1 = 0 ;
52512 PyObject * obj2 = 0 ;
52513 char * kwnames[] = {
52514 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52515 };
52516
52517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52519 if (!SWIG_IsOK(res1)) {
52520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52521 }
52522 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52524 if (!SWIG_IsOK(res2)) {
52525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52526 }
52527 arg2 = reinterpret_cast< wxWindow * >(argp2);
52528 if (obj2) {
52529 ecode3 = SWIG_AsVal_int(obj2, &val3);
52530 if (!SWIG_IsOK(ecode3)) {
52531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52532 }
52533 arg3 = static_cast< int >(val3);
52534 }
52535 {
52536 PyThreadState* __tstate = wxPyBeginAllowThreads();
52537 (arg1)->Above(arg2,arg3);
52538 wxPyEndAllowThreads(__tstate);
52539 if (PyErr_Occurred()) SWIG_fail;
52540 }
52541 resultobj = SWIG_Py_Void();
52542 return resultobj;
52543 fail:
52544 return NULL;
52545 }
52546
52547
52548 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52549 PyObject *resultobj = 0;
52550 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52551 wxWindow *arg2 = (wxWindow *) 0 ;
52552 int arg3 = (int) 0 ;
52553 void *argp1 = 0 ;
52554 int res1 = 0 ;
52555 void *argp2 = 0 ;
52556 int res2 = 0 ;
52557 int val3 ;
52558 int ecode3 = 0 ;
52559 PyObject * obj0 = 0 ;
52560 PyObject * obj1 = 0 ;
52561 PyObject * obj2 = 0 ;
52562 char * kwnames[] = {
52563 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52564 };
52565
52566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52568 if (!SWIG_IsOK(res1)) {
52569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52570 }
52571 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52573 if (!SWIG_IsOK(res2)) {
52574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52575 }
52576 arg2 = reinterpret_cast< wxWindow * >(argp2);
52577 if (obj2) {
52578 ecode3 = SWIG_AsVal_int(obj2, &val3);
52579 if (!SWIG_IsOK(ecode3)) {
52580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52581 }
52582 arg3 = static_cast< int >(val3);
52583 }
52584 {
52585 PyThreadState* __tstate = wxPyBeginAllowThreads();
52586 (arg1)->Below(arg2,arg3);
52587 wxPyEndAllowThreads(__tstate);
52588 if (PyErr_Occurred()) SWIG_fail;
52589 }
52590 resultobj = SWIG_Py_Void();
52591 return resultobj;
52592 fail:
52593 return NULL;
52594 }
52595
52596
52597 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52598 PyObject *resultobj = 0;
52599 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52600 wxWindow *arg2 = (wxWindow *) 0 ;
52601 wxEdge arg3 ;
52602 int arg4 = (int) 0 ;
52603 void *argp1 = 0 ;
52604 int res1 = 0 ;
52605 void *argp2 = 0 ;
52606 int res2 = 0 ;
52607 int val3 ;
52608 int ecode3 = 0 ;
52609 int val4 ;
52610 int ecode4 = 0 ;
52611 PyObject * obj0 = 0 ;
52612 PyObject * obj1 = 0 ;
52613 PyObject * obj2 = 0 ;
52614 PyObject * obj3 = 0 ;
52615 char * kwnames[] = {
52616 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52617 };
52618
52619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52621 if (!SWIG_IsOK(res1)) {
52622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52623 }
52624 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52626 if (!SWIG_IsOK(res2)) {
52627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52628 }
52629 arg2 = reinterpret_cast< wxWindow * >(argp2);
52630 ecode3 = SWIG_AsVal_int(obj2, &val3);
52631 if (!SWIG_IsOK(ecode3)) {
52632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52633 }
52634 arg3 = static_cast< wxEdge >(val3);
52635 if (obj3) {
52636 ecode4 = SWIG_AsVal_int(obj3, &val4);
52637 if (!SWIG_IsOK(ecode4)) {
52638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52639 }
52640 arg4 = static_cast< int >(val4);
52641 }
52642 {
52643 PyThreadState* __tstate = wxPyBeginAllowThreads();
52644 (arg1)->SameAs(arg2,arg3,arg4);
52645 wxPyEndAllowThreads(__tstate);
52646 if (PyErr_Occurred()) SWIG_fail;
52647 }
52648 resultobj = SWIG_Py_Void();
52649 return resultobj;
52650 fail:
52651 return NULL;
52652 }
52653
52654
52655 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52656 PyObject *resultobj = 0;
52657 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52658 wxWindow *arg2 = (wxWindow *) 0 ;
52659 wxEdge arg3 ;
52660 int arg4 ;
52661 void *argp1 = 0 ;
52662 int res1 = 0 ;
52663 void *argp2 = 0 ;
52664 int res2 = 0 ;
52665 int val3 ;
52666 int ecode3 = 0 ;
52667 int val4 ;
52668 int ecode4 = 0 ;
52669 PyObject * obj0 = 0 ;
52670 PyObject * obj1 = 0 ;
52671 PyObject * obj2 = 0 ;
52672 PyObject * obj3 = 0 ;
52673 char * kwnames[] = {
52674 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52675 };
52676
52677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52679 if (!SWIG_IsOK(res1)) {
52680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52681 }
52682 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52684 if (!SWIG_IsOK(res2)) {
52685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52686 }
52687 arg2 = reinterpret_cast< wxWindow * >(argp2);
52688 ecode3 = SWIG_AsVal_int(obj2, &val3);
52689 if (!SWIG_IsOK(ecode3)) {
52690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52691 }
52692 arg3 = static_cast< wxEdge >(val3);
52693 ecode4 = SWIG_AsVal_int(obj3, &val4);
52694 if (!SWIG_IsOK(ecode4)) {
52695 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52696 }
52697 arg4 = static_cast< int >(val4);
52698 {
52699 PyThreadState* __tstate = wxPyBeginAllowThreads();
52700 (arg1)->PercentOf(arg2,arg3,arg4);
52701 wxPyEndAllowThreads(__tstate);
52702 if (PyErr_Occurred()) SWIG_fail;
52703 }
52704 resultobj = SWIG_Py_Void();
52705 return resultobj;
52706 fail:
52707 return NULL;
52708 }
52709
52710
52711 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52712 PyObject *resultobj = 0;
52713 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52714 int arg2 ;
52715 void *argp1 = 0 ;
52716 int res1 = 0 ;
52717 int val2 ;
52718 int ecode2 = 0 ;
52719 PyObject * obj0 = 0 ;
52720 PyObject * obj1 = 0 ;
52721 char * kwnames[] = {
52722 (char *) "self",(char *) "val", NULL
52723 };
52724
52725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52727 if (!SWIG_IsOK(res1)) {
52728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52729 }
52730 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52731 ecode2 = SWIG_AsVal_int(obj1, &val2);
52732 if (!SWIG_IsOK(ecode2)) {
52733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52734 }
52735 arg2 = static_cast< int >(val2);
52736 {
52737 PyThreadState* __tstate = wxPyBeginAllowThreads();
52738 (arg1)->Absolute(arg2);
52739 wxPyEndAllowThreads(__tstate);
52740 if (PyErr_Occurred()) SWIG_fail;
52741 }
52742 resultobj = SWIG_Py_Void();
52743 return resultobj;
52744 fail:
52745 return NULL;
52746 }
52747
52748
52749 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52750 PyObject *resultobj = 0;
52751 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52752 void *argp1 = 0 ;
52753 int res1 = 0 ;
52754 PyObject *swig_obj[1] ;
52755
52756 if (!args) SWIG_fail;
52757 swig_obj[0] = args;
52758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52759 if (!SWIG_IsOK(res1)) {
52760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52761 }
52762 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52763 {
52764 PyThreadState* __tstate = wxPyBeginAllowThreads();
52765 (arg1)->Unconstrained();
52766 wxPyEndAllowThreads(__tstate);
52767 if (PyErr_Occurred()) SWIG_fail;
52768 }
52769 resultobj = SWIG_Py_Void();
52770 return resultobj;
52771 fail:
52772 return NULL;
52773 }
52774
52775
52776 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52777 PyObject *resultobj = 0;
52778 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52779 void *argp1 = 0 ;
52780 int res1 = 0 ;
52781 PyObject *swig_obj[1] ;
52782
52783 if (!args) SWIG_fail;
52784 swig_obj[0] = args;
52785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52786 if (!SWIG_IsOK(res1)) {
52787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52788 }
52789 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52790 {
52791 PyThreadState* __tstate = wxPyBeginAllowThreads();
52792 (arg1)->AsIs();
52793 wxPyEndAllowThreads(__tstate);
52794 if (PyErr_Occurred()) SWIG_fail;
52795 }
52796 resultobj = SWIG_Py_Void();
52797 return resultobj;
52798 fail:
52799 return NULL;
52800 }
52801
52802
52803 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52804 PyObject *resultobj = 0;
52805 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52806 wxWindow *result = 0 ;
52807 void *argp1 = 0 ;
52808 int res1 = 0 ;
52809 PyObject *swig_obj[1] ;
52810
52811 if (!args) SWIG_fail;
52812 swig_obj[0] = args;
52813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52814 if (!SWIG_IsOK(res1)) {
52815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52816 }
52817 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52818 {
52819 PyThreadState* __tstate = wxPyBeginAllowThreads();
52820 result = (wxWindow *)(arg1)->GetOtherWindow();
52821 wxPyEndAllowThreads(__tstate);
52822 if (PyErr_Occurred()) SWIG_fail;
52823 }
52824 {
52825 resultobj = wxPyMake_wxObject(result, 0);
52826 }
52827 return resultobj;
52828 fail:
52829 return NULL;
52830 }
52831
52832
52833 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52834 PyObject *resultobj = 0;
52835 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52836 wxEdge result;
52837 void *argp1 = 0 ;
52838 int res1 = 0 ;
52839 PyObject *swig_obj[1] ;
52840
52841 if (!args) SWIG_fail;
52842 swig_obj[0] = args;
52843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52844 if (!SWIG_IsOK(res1)) {
52845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52846 }
52847 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52848 {
52849 PyThreadState* __tstate = wxPyBeginAllowThreads();
52850 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52851 wxPyEndAllowThreads(__tstate);
52852 if (PyErr_Occurred()) SWIG_fail;
52853 }
52854 resultobj = SWIG_From_int(static_cast< int >(result));
52855 return resultobj;
52856 fail:
52857 return NULL;
52858 }
52859
52860
52861 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52862 PyObject *resultobj = 0;
52863 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52864 wxEdge arg2 ;
52865 void *argp1 = 0 ;
52866 int res1 = 0 ;
52867 int val2 ;
52868 int ecode2 = 0 ;
52869 PyObject * obj0 = 0 ;
52870 PyObject * obj1 = 0 ;
52871 char * kwnames[] = {
52872 (char *) "self",(char *) "which", NULL
52873 };
52874
52875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52877 if (!SWIG_IsOK(res1)) {
52878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52879 }
52880 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52881 ecode2 = SWIG_AsVal_int(obj1, &val2);
52882 if (!SWIG_IsOK(ecode2)) {
52883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52884 }
52885 arg2 = static_cast< wxEdge >(val2);
52886 {
52887 PyThreadState* __tstate = wxPyBeginAllowThreads();
52888 (arg1)->SetEdge(arg2);
52889 wxPyEndAllowThreads(__tstate);
52890 if (PyErr_Occurred()) SWIG_fail;
52891 }
52892 resultobj = SWIG_Py_Void();
52893 return resultobj;
52894 fail:
52895 return NULL;
52896 }
52897
52898
52899 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52900 PyObject *resultobj = 0;
52901 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52902 int arg2 ;
52903 void *argp1 = 0 ;
52904 int res1 = 0 ;
52905 int val2 ;
52906 int ecode2 = 0 ;
52907 PyObject * obj0 = 0 ;
52908 PyObject * obj1 = 0 ;
52909 char * kwnames[] = {
52910 (char *) "self",(char *) "v", NULL
52911 };
52912
52913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52915 if (!SWIG_IsOK(res1)) {
52916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52917 }
52918 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52919 ecode2 = SWIG_AsVal_int(obj1, &val2);
52920 if (!SWIG_IsOK(ecode2)) {
52921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52922 }
52923 arg2 = static_cast< int >(val2);
52924 {
52925 PyThreadState* __tstate = wxPyBeginAllowThreads();
52926 (arg1)->SetValue(arg2);
52927 wxPyEndAllowThreads(__tstate);
52928 if (PyErr_Occurred()) SWIG_fail;
52929 }
52930 resultobj = SWIG_Py_Void();
52931 return resultobj;
52932 fail:
52933 return NULL;
52934 }
52935
52936
52937 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52938 PyObject *resultobj = 0;
52939 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52940 int result;
52941 void *argp1 = 0 ;
52942 int res1 = 0 ;
52943 PyObject *swig_obj[1] ;
52944
52945 if (!args) SWIG_fail;
52946 swig_obj[0] = args;
52947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52948 if (!SWIG_IsOK(res1)) {
52949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52950 }
52951 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52952 {
52953 PyThreadState* __tstate = wxPyBeginAllowThreads();
52954 result = (int)(arg1)->GetMargin();
52955 wxPyEndAllowThreads(__tstate);
52956 if (PyErr_Occurred()) SWIG_fail;
52957 }
52958 resultobj = SWIG_From_int(static_cast< int >(result));
52959 return resultobj;
52960 fail:
52961 return NULL;
52962 }
52963
52964
52965 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52966 PyObject *resultobj = 0;
52967 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52968 int arg2 ;
52969 void *argp1 = 0 ;
52970 int res1 = 0 ;
52971 int val2 ;
52972 int ecode2 = 0 ;
52973 PyObject * obj0 = 0 ;
52974 PyObject * obj1 = 0 ;
52975 char * kwnames[] = {
52976 (char *) "self",(char *) "m", NULL
52977 };
52978
52979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52981 if (!SWIG_IsOK(res1)) {
52982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52983 }
52984 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52985 ecode2 = SWIG_AsVal_int(obj1, &val2);
52986 if (!SWIG_IsOK(ecode2)) {
52987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52988 }
52989 arg2 = static_cast< int >(val2);
52990 {
52991 PyThreadState* __tstate = wxPyBeginAllowThreads();
52992 (arg1)->SetMargin(arg2);
52993 wxPyEndAllowThreads(__tstate);
52994 if (PyErr_Occurred()) SWIG_fail;
52995 }
52996 resultobj = SWIG_Py_Void();
52997 return resultobj;
52998 fail:
52999 return NULL;
53000 }
53001
53002
53003 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53004 PyObject *resultobj = 0;
53005 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53006 int result;
53007 void *argp1 = 0 ;
53008 int res1 = 0 ;
53009 PyObject *swig_obj[1] ;
53010
53011 if (!args) SWIG_fail;
53012 swig_obj[0] = args;
53013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53014 if (!SWIG_IsOK(res1)) {
53015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53016 }
53017 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53018 {
53019 PyThreadState* __tstate = wxPyBeginAllowThreads();
53020 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53021 wxPyEndAllowThreads(__tstate);
53022 if (PyErr_Occurred()) SWIG_fail;
53023 }
53024 resultobj = SWIG_From_int(static_cast< int >(result));
53025 return resultobj;
53026 fail:
53027 return NULL;
53028 }
53029
53030
53031 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53032 PyObject *resultobj = 0;
53033 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53034 int result;
53035 void *argp1 = 0 ;
53036 int res1 = 0 ;
53037 PyObject *swig_obj[1] ;
53038
53039 if (!args) SWIG_fail;
53040 swig_obj[0] = args;
53041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53042 if (!SWIG_IsOK(res1)) {
53043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53044 }
53045 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53046 {
53047 PyThreadState* __tstate = wxPyBeginAllowThreads();
53048 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53049 wxPyEndAllowThreads(__tstate);
53050 if (PyErr_Occurred()) SWIG_fail;
53051 }
53052 resultobj = SWIG_From_int(static_cast< int >(result));
53053 return resultobj;
53054 fail:
53055 return NULL;
53056 }
53057
53058
53059 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53060 PyObject *resultobj = 0;
53061 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53062 int result;
53063 void *argp1 = 0 ;
53064 int res1 = 0 ;
53065 PyObject *swig_obj[1] ;
53066
53067 if (!args) SWIG_fail;
53068 swig_obj[0] = args;
53069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53070 if (!SWIG_IsOK(res1)) {
53071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53072 }
53073 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53074 {
53075 PyThreadState* __tstate = wxPyBeginAllowThreads();
53076 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53077 wxPyEndAllowThreads(__tstate);
53078 if (PyErr_Occurred()) SWIG_fail;
53079 }
53080 resultobj = SWIG_From_int(static_cast< int >(result));
53081 return resultobj;
53082 fail:
53083 return NULL;
53084 }
53085
53086
53087 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53088 PyObject *resultobj = 0;
53089 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53090 bool result;
53091 void *argp1 = 0 ;
53092 int res1 = 0 ;
53093 PyObject *swig_obj[1] ;
53094
53095 if (!args) SWIG_fail;
53096 swig_obj[0] = args;
53097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53098 if (!SWIG_IsOK(res1)) {
53099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53100 }
53101 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53102 {
53103 PyThreadState* __tstate = wxPyBeginAllowThreads();
53104 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53105 wxPyEndAllowThreads(__tstate);
53106 if (PyErr_Occurred()) SWIG_fail;
53107 }
53108 {
53109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53110 }
53111 return resultobj;
53112 fail:
53113 return NULL;
53114 }
53115
53116
53117 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53118 PyObject *resultobj = 0;
53119 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53120 bool arg2 ;
53121 void *argp1 = 0 ;
53122 int res1 = 0 ;
53123 bool val2 ;
53124 int ecode2 = 0 ;
53125 PyObject * obj0 = 0 ;
53126 PyObject * obj1 = 0 ;
53127 char * kwnames[] = {
53128 (char *) "self",(char *) "d", NULL
53129 };
53130
53131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53133 if (!SWIG_IsOK(res1)) {
53134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53135 }
53136 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53137 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53138 if (!SWIG_IsOK(ecode2)) {
53139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53140 }
53141 arg2 = static_cast< bool >(val2);
53142 {
53143 PyThreadState* __tstate = wxPyBeginAllowThreads();
53144 (arg1)->SetDone(arg2);
53145 wxPyEndAllowThreads(__tstate);
53146 if (PyErr_Occurred()) SWIG_fail;
53147 }
53148 resultobj = SWIG_Py_Void();
53149 return resultobj;
53150 fail:
53151 return NULL;
53152 }
53153
53154
53155 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53156 PyObject *resultobj = 0;
53157 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53158 wxRelationship result;
53159 void *argp1 = 0 ;
53160 int res1 = 0 ;
53161 PyObject *swig_obj[1] ;
53162
53163 if (!args) SWIG_fail;
53164 swig_obj[0] = args;
53165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53166 if (!SWIG_IsOK(res1)) {
53167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53168 }
53169 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53170 {
53171 PyThreadState* __tstate = wxPyBeginAllowThreads();
53172 result = (wxRelationship)(arg1)->GetRelationship();
53173 wxPyEndAllowThreads(__tstate);
53174 if (PyErr_Occurred()) SWIG_fail;
53175 }
53176 resultobj = SWIG_From_int(static_cast< int >(result));
53177 return resultobj;
53178 fail:
53179 return NULL;
53180 }
53181
53182
53183 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53184 PyObject *resultobj = 0;
53185 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53186 wxRelationship arg2 ;
53187 void *argp1 = 0 ;
53188 int res1 = 0 ;
53189 int val2 ;
53190 int ecode2 = 0 ;
53191 PyObject * obj0 = 0 ;
53192 PyObject * obj1 = 0 ;
53193 char * kwnames[] = {
53194 (char *) "self",(char *) "r", NULL
53195 };
53196
53197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53199 if (!SWIG_IsOK(res1)) {
53200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53201 }
53202 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53203 ecode2 = SWIG_AsVal_int(obj1, &val2);
53204 if (!SWIG_IsOK(ecode2)) {
53205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53206 }
53207 arg2 = static_cast< wxRelationship >(val2);
53208 {
53209 PyThreadState* __tstate = wxPyBeginAllowThreads();
53210 (arg1)->SetRelationship(arg2);
53211 wxPyEndAllowThreads(__tstate);
53212 if (PyErr_Occurred()) SWIG_fail;
53213 }
53214 resultobj = SWIG_Py_Void();
53215 return resultobj;
53216 fail:
53217 return NULL;
53218 }
53219
53220
53221 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53222 PyObject *resultobj = 0;
53223 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53224 wxWindow *arg2 = (wxWindow *) 0 ;
53225 bool result;
53226 void *argp1 = 0 ;
53227 int res1 = 0 ;
53228 void *argp2 = 0 ;
53229 int res2 = 0 ;
53230 PyObject * obj0 = 0 ;
53231 PyObject * obj1 = 0 ;
53232 char * kwnames[] = {
53233 (char *) "self",(char *) "otherW", NULL
53234 };
53235
53236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53238 if (!SWIG_IsOK(res1)) {
53239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53240 }
53241 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53243 if (!SWIG_IsOK(res2)) {
53244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53245 }
53246 arg2 = reinterpret_cast< wxWindow * >(argp2);
53247 {
53248 PyThreadState* __tstate = wxPyBeginAllowThreads();
53249 result = (bool)(arg1)->ResetIfWin(arg2);
53250 wxPyEndAllowThreads(__tstate);
53251 if (PyErr_Occurred()) SWIG_fail;
53252 }
53253 {
53254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53255 }
53256 return resultobj;
53257 fail:
53258 return NULL;
53259 }
53260
53261
53262 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53263 PyObject *resultobj = 0;
53264 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53265 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53266 wxWindow *arg3 = (wxWindow *) 0 ;
53267 bool result;
53268 void *argp1 = 0 ;
53269 int res1 = 0 ;
53270 void *argp2 = 0 ;
53271 int res2 = 0 ;
53272 void *argp3 = 0 ;
53273 int res3 = 0 ;
53274 PyObject * obj0 = 0 ;
53275 PyObject * obj1 = 0 ;
53276 PyObject * obj2 = 0 ;
53277 char * kwnames[] = {
53278 (char *) "self",(char *) "constraints",(char *) "win", NULL
53279 };
53280
53281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53283 if (!SWIG_IsOK(res1)) {
53284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53285 }
53286 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53288 if (!SWIG_IsOK(res2)) {
53289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53290 }
53291 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53292 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53293 if (!SWIG_IsOK(res3)) {
53294 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53295 }
53296 arg3 = reinterpret_cast< wxWindow * >(argp3);
53297 {
53298 PyThreadState* __tstate = wxPyBeginAllowThreads();
53299 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53300 wxPyEndAllowThreads(__tstate);
53301 if (PyErr_Occurred()) SWIG_fail;
53302 }
53303 {
53304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53305 }
53306 return resultobj;
53307 fail:
53308 return NULL;
53309 }
53310
53311
53312 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53313 PyObject *resultobj = 0;
53314 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53315 wxEdge arg2 ;
53316 wxWindow *arg3 = (wxWindow *) 0 ;
53317 wxWindow *arg4 = (wxWindow *) 0 ;
53318 int result;
53319 void *argp1 = 0 ;
53320 int res1 = 0 ;
53321 int val2 ;
53322 int ecode2 = 0 ;
53323 void *argp3 = 0 ;
53324 int res3 = 0 ;
53325 void *argp4 = 0 ;
53326 int res4 = 0 ;
53327 PyObject * obj0 = 0 ;
53328 PyObject * obj1 = 0 ;
53329 PyObject * obj2 = 0 ;
53330 PyObject * obj3 = 0 ;
53331 char * kwnames[] = {
53332 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53333 };
53334
53335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53337 if (!SWIG_IsOK(res1)) {
53338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53339 }
53340 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53341 ecode2 = SWIG_AsVal_int(obj1, &val2);
53342 if (!SWIG_IsOK(ecode2)) {
53343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53344 }
53345 arg2 = static_cast< wxEdge >(val2);
53346 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53347 if (!SWIG_IsOK(res3)) {
53348 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53349 }
53350 arg3 = reinterpret_cast< wxWindow * >(argp3);
53351 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53352 if (!SWIG_IsOK(res4)) {
53353 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53354 }
53355 arg4 = reinterpret_cast< wxWindow * >(argp4);
53356 {
53357 PyThreadState* __tstate = wxPyBeginAllowThreads();
53358 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53359 wxPyEndAllowThreads(__tstate);
53360 if (PyErr_Occurred()) SWIG_fail;
53361 }
53362 resultobj = SWIG_From_int(static_cast< int >(result));
53363 return resultobj;
53364 fail:
53365 return NULL;
53366 }
53367
53368
53369 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53370 PyObject *obj;
53371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53372 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53373 return SWIG_Py_Void();
53374 }
53375
53376 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53377 PyObject *resultobj = 0;
53378 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53379 wxIndividualLayoutConstraint *result = 0 ;
53380 void *argp1 = 0 ;
53381 int res1 = 0 ;
53382 PyObject *swig_obj[1] ;
53383
53384 if (!args) SWIG_fail;
53385 swig_obj[0] = args;
53386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53387 if (!SWIG_IsOK(res1)) {
53388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53389 }
53390 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53391 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53393 return resultobj;
53394 fail:
53395 return NULL;
53396 }
53397
53398
53399 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53400 PyObject *resultobj = 0;
53401 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53402 wxIndividualLayoutConstraint *result = 0 ;
53403 void *argp1 = 0 ;
53404 int res1 = 0 ;
53405 PyObject *swig_obj[1] ;
53406
53407 if (!args) SWIG_fail;
53408 swig_obj[0] = args;
53409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53410 if (!SWIG_IsOK(res1)) {
53411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53412 }
53413 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53414 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53416 return resultobj;
53417 fail:
53418 return NULL;
53419 }
53420
53421
53422 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53423 PyObject *resultobj = 0;
53424 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53425 wxIndividualLayoutConstraint *result = 0 ;
53426 void *argp1 = 0 ;
53427 int res1 = 0 ;
53428 PyObject *swig_obj[1] ;
53429
53430 if (!args) SWIG_fail;
53431 swig_obj[0] = args;
53432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53433 if (!SWIG_IsOK(res1)) {
53434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53435 }
53436 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53437 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53439 return resultobj;
53440 fail:
53441 return NULL;
53442 }
53443
53444
53445 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53446 PyObject *resultobj = 0;
53447 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53448 wxIndividualLayoutConstraint *result = 0 ;
53449 void *argp1 = 0 ;
53450 int res1 = 0 ;
53451 PyObject *swig_obj[1] ;
53452
53453 if (!args) SWIG_fail;
53454 swig_obj[0] = args;
53455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53456 if (!SWIG_IsOK(res1)) {
53457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53458 }
53459 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53460 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53462 return resultobj;
53463 fail:
53464 return NULL;
53465 }
53466
53467
53468 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53469 PyObject *resultobj = 0;
53470 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53471 wxIndividualLayoutConstraint *result = 0 ;
53472 void *argp1 = 0 ;
53473 int res1 = 0 ;
53474 PyObject *swig_obj[1] ;
53475
53476 if (!args) SWIG_fail;
53477 swig_obj[0] = args;
53478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53479 if (!SWIG_IsOK(res1)) {
53480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53481 }
53482 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53483 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53485 return resultobj;
53486 fail:
53487 return NULL;
53488 }
53489
53490
53491 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53492 PyObject *resultobj = 0;
53493 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53494 wxIndividualLayoutConstraint *result = 0 ;
53495 void *argp1 = 0 ;
53496 int res1 = 0 ;
53497 PyObject *swig_obj[1] ;
53498
53499 if (!args) SWIG_fail;
53500 swig_obj[0] = args;
53501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53502 if (!SWIG_IsOK(res1)) {
53503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53504 }
53505 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53506 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53508 return resultobj;
53509 fail:
53510 return NULL;
53511 }
53512
53513
53514 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53515 PyObject *resultobj = 0;
53516 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53517 wxIndividualLayoutConstraint *result = 0 ;
53518 void *argp1 = 0 ;
53519 int res1 = 0 ;
53520 PyObject *swig_obj[1] ;
53521
53522 if (!args) SWIG_fail;
53523 swig_obj[0] = args;
53524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53525 if (!SWIG_IsOK(res1)) {
53526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53527 }
53528 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53529 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53531 return resultobj;
53532 fail:
53533 return NULL;
53534 }
53535
53536
53537 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53538 PyObject *resultobj = 0;
53539 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53540 wxIndividualLayoutConstraint *result = 0 ;
53541 void *argp1 = 0 ;
53542 int res1 = 0 ;
53543 PyObject *swig_obj[1] ;
53544
53545 if (!args) SWIG_fail;
53546 swig_obj[0] = args;
53547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53548 if (!SWIG_IsOK(res1)) {
53549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53550 }
53551 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53552 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53554 return resultobj;
53555 fail:
53556 return NULL;
53557 }
53558
53559
53560 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53561 PyObject *resultobj = 0;
53562 wxLayoutConstraints *result = 0 ;
53563
53564 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53565 {
53566 PyThreadState* __tstate = wxPyBeginAllowThreads();
53567 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53568 wxPyEndAllowThreads(__tstate);
53569 if (PyErr_Occurred()) SWIG_fail;
53570 }
53571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53572 return resultobj;
53573 fail:
53574 return NULL;
53575 }
53576
53577
53578 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53579 PyObject *resultobj = 0;
53580 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53581 void *argp1 = 0 ;
53582 int res1 = 0 ;
53583 PyObject *swig_obj[1] ;
53584
53585 if (!args) SWIG_fail;
53586 swig_obj[0] = args;
53587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53588 if (!SWIG_IsOK(res1)) {
53589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53590 }
53591 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53592 {
53593 PyThreadState* __tstate = wxPyBeginAllowThreads();
53594 delete arg1;
53595
53596 wxPyEndAllowThreads(__tstate);
53597 if (PyErr_Occurred()) SWIG_fail;
53598 }
53599 resultobj = SWIG_Py_Void();
53600 return resultobj;
53601 fail:
53602 return NULL;
53603 }
53604
53605
53606 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53607 PyObject *resultobj = 0;
53608 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53609 wxWindow *arg2 = (wxWindow *) 0 ;
53610 int *arg3 = (int *) 0 ;
53611 bool result;
53612 void *argp1 = 0 ;
53613 int res1 = 0 ;
53614 void *argp2 = 0 ;
53615 int res2 = 0 ;
53616 int temp3 ;
53617 int res3 = SWIG_TMPOBJ ;
53618 PyObject * obj0 = 0 ;
53619 PyObject * obj1 = 0 ;
53620 char * kwnames[] = {
53621 (char *) "self",(char *) "win", NULL
53622 };
53623
53624 arg3 = &temp3;
53625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53627 if (!SWIG_IsOK(res1)) {
53628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53629 }
53630 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53631 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53632 if (!SWIG_IsOK(res2)) {
53633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53634 }
53635 arg2 = reinterpret_cast< wxWindow * >(argp2);
53636 {
53637 PyThreadState* __tstate = wxPyBeginAllowThreads();
53638 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53639 wxPyEndAllowThreads(__tstate);
53640 if (PyErr_Occurred()) SWIG_fail;
53641 }
53642 {
53643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53644 }
53645 if (SWIG_IsTmpObj(res3)) {
53646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53647 } else {
53648 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53650 }
53651 return resultobj;
53652 fail:
53653 return NULL;
53654 }
53655
53656
53657 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53658 PyObject *resultobj = 0;
53659 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53660 bool result;
53661 void *argp1 = 0 ;
53662 int res1 = 0 ;
53663 PyObject *swig_obj[1] ;
53664
53665 if (!args) SWIG_fail;
53666 swig_obj[0] = args;
53667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53668 if (!SWIG_IsOK(res1)) {
53669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53670 }
53671 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53672 {
53673 PyThreadState* __tstate = wxPyBeginAllowThreads();
53674 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53675 wxPyEndAllowThreads(__tstate);
53676 if (PyErr_Occurred()) SWIG_fail;
53677 }
53678 {
53679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53680 }
53681 return resultobj;
53682 fail:
53683 return NULL;
53684 }
53685
53686
53687 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53688 PyObject *obj;
53689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53690 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53691 return SWIG_Py_Void();
53692 }
53693
53694 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53695 return SWIG_Python_InitShadowInstance(args);
53696 }
53697
53698 static PyMethodDef SwigMethods[] = {
53699 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53700 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53701 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53702 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53703 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53704 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53705 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53706 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53707 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53709 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53720 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53721 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53722 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53724 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53725 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53726 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53727 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53728 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53729 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53730 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53732 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53738 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53739 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53740 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53741 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53742 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53743 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53744 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53746 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53754 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53755 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53756 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53761 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53762 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53764 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53766 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53768 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53770 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53772 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53774 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53775 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53777 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53779 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53780 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53781 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53782 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53802 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53803 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53804 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53805 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53806 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53807 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53808 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53809 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53811 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53812 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53813 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53818 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53819 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53820 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53821 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53828 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53835 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53836 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53837 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53838 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53840 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53841 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53842 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53844 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53845 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53846 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53847 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53852 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53853 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53854 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53855 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53856 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53857 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53860 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53861 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53862 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53864 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53865 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53867 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53868 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53869 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53870 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53871 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53872 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53873 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53874 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53875 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53876 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53877 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53878 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53883 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53889 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53890 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53891 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53892 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53894 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53897 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53900 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53903 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53904 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53905 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53908 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53909 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53910 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53914 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53915 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53916 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53920 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53925 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53926 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53927 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53928 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53929 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53930 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53931 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53938 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53939 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53941 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53942 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53943 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53949 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53950 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53952 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53953 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53954 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53955 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53956 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53957 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53958 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53959 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53961 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53962 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53963 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53964 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53965 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53966 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53967 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53968 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53970 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53979 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53991 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53992 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54007 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54008 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54009 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54010 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54013 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54015 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54017 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54019 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54021 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54024 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54025 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54026 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54027 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54029 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54046 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54047 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54053 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54054 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54056 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54057 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54058 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54059 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54060 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54061 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54062 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54063 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54064 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54065 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54066 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54067 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54068 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54069 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54070 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54071 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54072 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54073 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54074 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54075 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54076 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54077 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54078 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54079 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54080 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54081 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54082 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54083 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54084 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54085 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54086 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54087 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54088 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54090 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54091 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54092 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54093 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54096 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54100 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54104 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54105 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54106 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54107 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54109 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54110 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54112 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54114 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54116 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54118 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54119 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54120 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54122 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54123 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54125 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54126 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54127 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54129 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54130 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54131 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54133 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54135 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54136 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54137 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54139 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54141 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54142 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54144 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54145 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54146 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54148 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54149 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54150 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54151 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54152 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54154 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54155 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54158 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54159 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54161 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54162 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54165 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54166 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54168 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54174 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54175 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54176 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54177 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54178 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54179 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54180 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54181 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54182 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54183 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54184 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54185 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54186 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54187 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54188 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54189 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54190 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54191 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54192 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54193 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54194 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54195 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54196 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54197 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54199 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54200 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54201 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54202 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54203 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54204 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54205 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54206 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54207 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54208 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54209 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54210 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54211 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54212 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54213 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54214 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54215 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54216 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54217 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54218 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54219 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54220 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54221 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54222 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54223 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54224 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54225 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54226 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54227 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54228 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54229 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54230 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54232 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54233 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54235 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54236 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54237 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54238 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54240 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54241 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54242 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54243 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54244 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54245 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54246 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54247 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54248 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54250 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54251 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54252 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54253 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54254 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54255 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54256 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54257 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54258 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54259 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54260 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54261 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54262 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54263 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54264 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54265 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54266 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54267 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54268 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54269 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54270 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54271 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54272 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54273 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54274 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54275 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54276 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54277 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54279 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54280 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54283 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54284 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54285 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54286 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54287 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54288 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54290 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54291 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54292 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54293 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54294 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54295 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54297 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54298 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54300 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54301 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54303 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54304 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54305 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54307 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54309 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54310 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54312 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54313 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54314 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54316 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54317 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54318 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54320 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54321 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54322 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54323 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54324 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54325 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54326 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54327 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54330 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54332 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54334 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54335 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54336 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54339 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54340 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54341 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54343 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54344 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54345 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54347 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54348 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54349 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54350 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54351 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54352 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54354 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54355 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54356 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54357 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54358 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54359 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54360 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54361 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54367 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54369 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54370 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54371 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54372 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54373 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54374 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54375 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54376 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54378 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54379 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54380 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54382 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54383 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54384 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54385 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54386 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54389 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54390 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54391 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54394 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54395 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54396 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54397 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54398 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54400 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54402 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54405 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54407 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54408 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54410 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54411 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54412 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54414 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54415 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54416 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54418 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54420 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54421 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54422 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54424 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54426 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54428 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54429 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54431 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54432 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54434 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54436 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54437 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54438 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54440 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54442 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54443 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54444 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54446 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54448 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54449 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54450 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54451 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54453 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54455 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54457 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54459 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54460 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54462 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54463 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54464 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54465 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54466 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54467 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54468 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54469 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54470 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54472 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54473 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54474 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54476 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54478 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54480 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54482 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54483 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54484 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54485 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54486 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54487 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54493 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54494 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
54495 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54496 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54497 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54498 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54499 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54500 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54502 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54504 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54505 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54507 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54508 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54509 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54510 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54512 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54513 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54514 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54515 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54517 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54518 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54520 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54521 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54522 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54524 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54527 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54528 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54529 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54530 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54531 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54533 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54534 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54536 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54537 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54538 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54539 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54541 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54542 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54543 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54544 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54545 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54546 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54547 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54548 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54549 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54550 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54552 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54553 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54554 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54555 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54556 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54557 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54558 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54559 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54561 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54562 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54563 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54564 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54565 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54566 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54567 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54568 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54569 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54572 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54578 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54579 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54580 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54584 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54585 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54586 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54587 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54588 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54589 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54590 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54591 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54592 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54593 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54594 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54595 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54596 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54597 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54598 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54600 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54601 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54604 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54605 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54610 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54611 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54614 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54615 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54616 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54617 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54620 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54621 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54622 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54624 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54626 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54627 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54628 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54630 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54632 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54634 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54637 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54638 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54639 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54640 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54641 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54642 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54646 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54647 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54648 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54649 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54652 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54653 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54655 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54656 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54661 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54662 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54663 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54664 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54665 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54666 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54667 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54668 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54674 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54675 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54676 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54677 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54678 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54679 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54680 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54681 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54682 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54684 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54685 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54686 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54687 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54688 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54689 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54690 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54691 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54692 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54694 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54699 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54700 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54701 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54702 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54703 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54705 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54706 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54707 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54708 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54711 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54713 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54714 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54715 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54716 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54717 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54718 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54721 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54722 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54724 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54727 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54728 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54729 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54731 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54738 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54739 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54742 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54743 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54744 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54745 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54749 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54751 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54752 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54754 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54757 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54759 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54760 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54763 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54764 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54765 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54766 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54767 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54768 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54770 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54771 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54776 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54777 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54778 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54780 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54781 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54782 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54784 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54786 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54787 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54788 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54790 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54791 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54793 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54794 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54795 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54802 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54803 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54805 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54807 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54809 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54811 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54812 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54813 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54814 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54815 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54816 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54817 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54818 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54819 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54820 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54821 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54822 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54834 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54836 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54838 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54839 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54841 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54843 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54844 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54845 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54846 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54847 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54848 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54849 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54852 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54856 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54862 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54864 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54865 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54870 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54871 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54872 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54873 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54874 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54875 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54877 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54878 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54879 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54881 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54882 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54885 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54886 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54888 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54889 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54891 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54894 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54895 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54897 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54899 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54900 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54901 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54902 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54903 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54904 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54905 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54908 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54910 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54912 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54913 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54914 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54917 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54919 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54920 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54921 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54923 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54924 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54925 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54927 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54928 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54929 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54930 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54932 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54934 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54935 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54937 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54939 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54943 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54944 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54946 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54947 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54948 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54950 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54952 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54953 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54954 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54955 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54956 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54957 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54961 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54962 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54963 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54964 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54966 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54967 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54969 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54972 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54973 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54974 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54975 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54976 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54978 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54980 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54982 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54983 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54985 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54987 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54988 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54990 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54991 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54992 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54993 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54994 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54995 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54996 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54997 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55005 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55006 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55008 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55009 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55015 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55016 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55017 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55018 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55019 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55020 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55023 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55026 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55027 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55031 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55032 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55034 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55035 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55037 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55039 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55040 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55042 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55043 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55044 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55045 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55050 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55051 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55052 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55053 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55054 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55055 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55062 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55064 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55065 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55066 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55067 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55068 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55069 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55070 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55071 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55075 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55076 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55077 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55078 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55079 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55080 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55081 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55083 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55084 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55085 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55088 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55091 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55092 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55093 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55095 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55096 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55097 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55102 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55103 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55104 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55105 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55106 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55107 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55111 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55112 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55117 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55118 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55120 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55121 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55124 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55126 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55128 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55129 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55130 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55131 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55132 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55133 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55137 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55138 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55139 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55141 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55142 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55145 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55146 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55147 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55148 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55149 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55150 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55152 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55153 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55155 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55156 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55157 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55158 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55160 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55164 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55165 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55166 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55167 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55168 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55169 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55170 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55171 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55172 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55173 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55174 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55175 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55177 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55178 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55179 { NULL, NULL, 0, NULL }
55180 };
55181
55182
55183 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55184
55185 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55186 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55187 }
55188 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55189 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55190 }
55191 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55192 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55193 }
55194 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55195 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55196 }
55197 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55198 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55199 }
55200 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55201 return (void *)((wxSizer *) ((wxGridSizer *) x));
55202 }
55203 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55204 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55205 }
55206 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55207 return (void *)((wxSizer *) ((wxPySizer *) x));
55208 }
55209 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55210 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55211 }
55212 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55213 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55214 }
55215 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55216 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55217 }
55218 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55219 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55220 }
55221 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55222 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55223 }
55224 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55225 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55226 }
55227 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55228 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55229 }
55230 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55231 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55232 }
55233 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55234 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55235 }
55236 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55237 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55238 }
55239 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55240 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55241 }
55242 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55243 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55244 }
55245 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55246 return (void *)((wxEvent *) ((wxPyEvent *) x));
55247 }
55248 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55249 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55250 }
55251 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55253 }
55254 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55255 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55256 }
55257 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55258 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55259 }
55260 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55261 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55262 }
55263 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55264 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55265 }
55266 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55267 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55268 }
55269 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55270 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55271 }
55272 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55273 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55274 }
55275 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55276 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55277 }
55278 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55279 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55280 }
55281 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55282 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55283 }
55284 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55285 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55286 }
55287 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55288 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55289 }
55290 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55291 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55292 }
55293 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55294 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55295 }
55296 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55297 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55298 }
55299 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55300 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55301 }
55302 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55303 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55304 }
55305 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55306 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55307 }
55308 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55309 return (void *)((wxEvent *) ((wxShowEvent *) x));
55310 }
55311 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55312 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55313 }
55314 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55315 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55316 }
55317 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55318 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55319 }
55320 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55321 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55322 }
55323 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55324 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55325 }
55326 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55327 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55328 }
55329 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55330 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55331 }
55332 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55333 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55334 }
55335 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55336 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55337 }
55338 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55339 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55340 }
55341 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55342 return (void *)((wxControl *) ((wxControlWithItems *) x));
55343 }
55344 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55345 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55346 }
55347 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55348 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55349 }
55350 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55351 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55352 }
55353 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55354 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55355 }
55356 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55357 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55358 }
55359 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55360 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55361 }
55362 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55363 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55364 }
55365 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55366 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55367 }
55368 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55369 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55370 }
55371 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55372 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55373 }
55374 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55375 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55376 }
55377 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55378 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55379 }
55380 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55381 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55382 }
55383 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55384 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55385 }
55386 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55387 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55388 }
55389 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55390 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55391 }
55392 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55393 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55394 }
55395 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55396 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55397 }
55398 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55399 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55400 }
55401 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55402 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55403 }
55404 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55405 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55406 }
55407 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55408 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55409 }
55410 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55411 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55412 }
55413 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55414 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55415 }
55416 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55417 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55418 }
55419 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55420 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55421 }
55422 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55423 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55424 }
55425 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55426 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55427 }
55428 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55429 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55430 }
55431 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55432 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55433 }
55434 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55435 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55436 }
55437 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55438 return (void *)((wxObject *) ((wxSizerItem *) x));
55439 }
55440 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55441 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55442 }
55443 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55445 }
55446 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55447 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55448 }
55449 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55450 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55451 }
55452 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55453 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55454 }
55455 static void *_p_wxSizerTo_p_wxObject(void *x) {
55456 return (void *)((wxObject *) ((wxSizer *) x));
55457 }
55458 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55459 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55460 }
55461 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55462 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55463 }
55464 static void *_p_wxEventTo_p_wxObject(void *x) {
55465 return (void *)((wxObject *) ((wxEvent *) x));
55466 }
55467 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55468 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55469 }
55470 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55471 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55472 }
55473 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55474 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55475 }
55476 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55477 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55478 }
55479 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55480 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55481 }
55482 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55483 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55484 }
55485 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55486 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55487 }
55488 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55489 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55490 }
55491 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55492 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55493 }
55494 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55495 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55496 }
55497 static void *_p_wxControlTo_p_wxObject(void *x) {
55498 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55499 }
55500 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55501 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55502 }
55503 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55504 return (void *)((wxObject *) ((wxFSFile *) x));
55505 }
55506 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55507 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55508 }
55509 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55510 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55511 }
55512 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55513 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55514 }
55515 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55516 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55517 }
55518 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55519 return (void *)((wxObject *) ((wxMenuItem *) x));
55520 }
55521 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55522 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55523 }
55524 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55525 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55526 }
55527 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55528 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55529 }
55530 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55531 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55532 }
55533 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55534 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55535 }
55536 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55537 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55538 }
55539 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55540 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55541 }
55542 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55543 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55544 }
55545 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55546 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55547 }
55548 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55549 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55550 }
55551 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55552 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55553 }
55554 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55555 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55556 }
55557 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55558 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55559 }
55560 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55561 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55562 }
55563 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55564 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55565 }
55566 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55567 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55568 }
55569 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55570 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55571 }
55572 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55573 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55574 }
55575 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55576 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55577 }
55578 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55579 return (void *)((wxObject *) ((wxImageHandler *) x));
55580 }
55581 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55582 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55583 }
55584 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55585 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55586 }
55587 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55588 return (void *)((wxObject *) ((wxEvtHandler *) x));
55589 }
55590 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55591 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55592 }
55593 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55594 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55595 }
55596 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55597 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55598 }
55599 static void *_p_wxImageTo_p_wxObject(void *x) {
55600 return (void *)((wxObject *) ((wxImage *) x));
55601 }
55602 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55603 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55604 }
55605 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55606 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55607 }
55608 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55609 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55610 }
55611 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55612 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55613 }
55614 static void *_p_wxWindowTo_p_wxObject(void *x) {
55615 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55616 }
55617 static void *_p_wxMenuTo_p_wxObject(void *x) {
55618 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55619 }
55620 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55621 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55622 }
55623 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55624 return (void *)((wxObject *) ((wxFileSystem *) x));
55625 }
55626 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55627 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55628 }
55629 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55630 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55631 }
55632 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55633 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55634 }
55635 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55636 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55637 }
55638 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55639 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55640 }
55641 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55642 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55643 }
55644 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55645 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55646 }
55647 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55648 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55649 }
55650 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55651 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55652 }
55653 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55654 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55655 }
55656 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55657 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55658 }
55659 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55660 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55661 }
55662 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55663 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55664 }
55665 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55666 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55667 }
55668 static void *_p_wxControlTo_p_wxWindow(void *x) {
55669 return (void *)((wxWindow *) ((wxControl *) x));
55670 }
55671 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55672 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55673 }
55674 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55675 return (void *)((wxWindow *) ((wxMenuBar *) x));
55676 }
55677 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55678 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55679 }
55680 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55681 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55682 }
55683 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55684 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55685 }
55686 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55687 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55688 }
55689 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55690 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55691 }
55692 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55693 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55694 }
55695 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55696 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55697 }
55698 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55699 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55700 }
55701 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55702 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55703 }
55704 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55705 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55706 }
55707 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55708 return (void *)((wxValidator *) ((wxPyValidator *) x));
55709 }
55710 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55711 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55712 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
55713 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55714 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55715 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55716 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55717 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55718 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55719 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55720 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55721 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55722 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55723 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55724 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55725 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55726 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55727 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55728 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55729 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55730 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55731 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55732 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55733 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55734 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55735 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55736 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55737 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55738 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55739 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55740 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55741 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55742 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55743 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55744 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55745 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55746 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55747 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55748 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55749 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55750 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55751 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55752 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55753 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55754 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55755 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55756 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55757 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55758 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55759 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55760 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55761 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55762 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55763 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55764 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55765 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55766 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55767 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55768 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55769 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55770 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55771 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55772 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55774 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55775 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxLayoutDirection = {"_p_wxLayoutDirection", "wxLayoutDirection *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55816 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55817 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55818 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55819 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55820 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55821 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55822 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55823 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55824 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55825 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55826 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55827 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55828 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55829 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55830 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55831 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55832 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55833 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55834 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55835 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55836 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55837 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55838 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55839 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55840 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55841 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55842 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55843
55844 static swig_type_info *swig_type_initial[] = {
55845 &_swigt__p_buffer,
55846 &_swigt__p_char,
55847 &_swigt__p_form_ops_t,
55848 &_swigt__p_int,
55849 &_swigt__p_long,
55850 &_swigt__p_unsigned_char,
55851 &_swigt__p_unsigned_int,
55852 &_swigt__p_unsigned_long,
55853 &_swigt__p_wxANIHandler,
55854 &_swigt__p_wxAcceleratorEntry,
55855 &_swigt__p_wxAcceleratorTable,
55856 &_swigt__p_wxActivateEvent,
55857 &_swigt__p_wxAppTraits,
55858 &_swigt__p_wxArrayString,
55859 &_swigt__p_wxBMPHandler,
55860 &_swigt__p_wxBitmap,
55861 &_swigt__p_wxBoxSizer,
55862 &_swigt__p_wxButton,
55863 &_swigt__p_wxCURHandler,
55864 &_swigt__p_wxCaret,
55865 &_swigt__p_wxChildFocusEvent,
55866 &_swigt__p_wxClipboardTextEvent,
55867 &_swigt__p_wxCloseEvent,
55868 &_swigt__p_wxColour,
55869 &_swigt__p_wxCommandEvent,
55870 &_swigt__p_wxContextMenuEvent,
55871 &_swigt__p_wxControl,
55872 &_swigt__p_wxControlWithItems,
55873 &_swigt__p_wxCursor,
55874 &_swigt__p_wxDC,
55875 &_swigt__p_wxDateEvent,
55876 &_swigt__p_wxDateTime,
55877 &_swigt__p_wxDisplayChangedEvent,
55878 &_swigt__p_wxDropFilesEvent,
55879 &_swigt__p_wxDuplexMode,
55880 &_swigt__p_wxEraseEvent,
55881 &_swigt__p_wxEvent,
55882 &_swigt__p_wxEventLoop,
55883 &_swigt__p_wxEventLoopActivator,
55884 &_swigt__p_wxEvtHandler,
55885 &_swigt__p_wxFSFile,
55886 &_swigt__p_wxFileSystem,
55887 &_swigt__p_wxFileSystemHandler,
55888 &_swigt__p_wxFlexGridSizer,
55889 &_swigt__p_wxFocusEvent,
55890 &_swigt__p_wxFont,
55891 &_swigt__p_wxFrame,
55892 &_swigt__p_wxGBPosition,
55893 &_swigt__p_wxGBSizerItem,
55894 &_swigt__p_wxGBSpan,
55895 &_swigt__p_wxGIFHandler,
55896 &_swigt__p_wxGridBagSizer,
55897 &_swigt__p_wxGridSizer,
55898 &_swigt__p_wxHelpEvent__Origin,
55899 &_swigt__p_wxICOHandler,
55900 &_swigt__p_wxIconizeEvent,
55901 &_swigt__p_wxIdleEvent,
55902 &_swigt__p_wxImage,
55903 &_swigt__p_wxImageHandler,
55904 &_swigt__p_wxImageHistogram,
55905 &_swigt__p_wxImage_HSVValue,
55906 &_swigt__p_wxImage_RGBValue,
55907 &_swigt__p_wxIndividualLayoutConstraint,
55908 &_swigt__p_wxInitDialogEvent,
55909 &_swigt__p_wxInputStream,
55910 &_swigt__p_wxInternetFSHandler,
55911 &_swigt__p_wxItemContainer,
55912 &_swigt__p_wxJPEGHandler,
55913 &_swigt__p_wxKeyEvent,
55914 &_swigt__p_wxLayoutConstraints,
55915 &_swigt__p_wxLayoutDirection,
55916 &_swigt__p_wxMaximizeEvent,
55917 &_swigt__p_wxMemoryFSHandler,
55918 &_swigt__p_wxMenu,
55919 &_swigt__p_wxMenuBar,
55920 &_swigt__p_wxMenuBarBase,
55921 &_swigt__p_wxMenuEvent,
55922 &_swigt__p_wxMenuItem,
55923 &_swigt__p_wxMouseCaptureChangedEvent,
55924 &_swigt__p_wxMouseCaptureLostEvent,
55925 &_swigt__p_wxMouseEvent,
55926 &_swigt__p_wxMoveEvent,
55927 &_swigt__p_wxNavigationKeyEvent,
55928 &_swigt__p_wxNcPaintEvent,
55929 &_swigt__p_wxNotifyEvent,
55930 &_swigt__p_wxObject,
55931 &_swigt__p_wxOutputStream,
55932 &_swigt__p_wxPCXHandler,
55933 &_swigt__p_wxPNGHandler,
55934 &_swigt__p_wxPNMHandler,
55935 &_swigt__p_wxPaintEvent,
55936 &_swigt__p_wxPaletteChangedEvent,
55937 &_swigt__p_wxPaperSize,
55938 &_swigt__p_wxPoint,
55939 &_swigt__p_wxPoint2D,
55940 &_swigt__p_wxPropagateOnce,
55941 &_swigt__p_wxPropagationDisabler,
55942 &_swigt__p_wxPyApp,
55943 &_swigt__p_wxPyCommandEvent,
55944 &_swigt__p_wxPyDropTarget,
55945 &_swigt__p_wxPyEvent,
55946 &_swigt__p_wxPyFileSystemHandler,
55947 &_swigt__p_wxPyImageHandler,
55948 &_swigt__p_wxPyInputStream,
55949 &_swigt__p_wxPySizer,
55950 &_swigt__p_wxPyValidator,
55951 &_swigt__p_wxQuantize,
55952 &_swigt__p_wxQueryNewPaletteEvent,
55953 &_swigt__p_wxRealPoint,
55954 &_swigt__p_wxRect,
55955 &_swigt__p_wxRegion,
55956 &_swigt__p_wxScrollEvent,
55957 &_swigt__p_wxScrollWinEvent,
55958 &_swigt__p_wxSetCursorEvent,
55959 &_swigt__p_wxShowEvent,
55960 &_swigt__p_wxSize,
55961 &_swigt__p_wxSizeEvent,
55962 &_swigt__p_wxSizer,
55963 &_swigt__p_wxSizerItem,
55964 &_swigt__p_wxStaticBox,
55965 &_swigt__p_wxStaticBoxSizer,
55966 &_swigt__p_wxStdDialogButtonSizer,
55967 &_swigt__p_wxSysColourChangedEvent,
55968 &_swigt__p_wxTIFFHandler,
55969 &_swigt__p_wxToolTip,
55970 &_swigt__p_wxUpdateUIEvent,
55971 &_swigt__p_wxValidator,
55972 &_swigt__p_wxVisualAttributes,
55973 &_swigt__p_wxWindow,
55974 &_swigt__p_wxWindowCreateEvent,
55975 &_swigt__p_wxWindowDestroyEvent,
55976 &_swigt__p_wxXPMHandler,
55977 &_swigt__p_wxZipFSHandler,
55978 };
55979
55980 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55981 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55982 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55983 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55984 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55985 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55986 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55987 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55988 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55989 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55990 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55991 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55992 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55993 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55994 static swig_cast_info _swigc__p_wxBMPHandler[] = { {&_swigt__p_wxBMPHandler, 0, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxBMPHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxBMPHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxBMPHandler, 0, 0},{0, 0, 0, 0}};
55995 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55996 static swig_cast_info _swigc__p_wxBoxSizer[] = { {&_swigt__p_wxBoxSizer, 0, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxBoxSizer, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxBoxSizer, 0, 0},{0, 0, 0, 0}};
55997 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55998 static swig_cast_info _swigc__p_wxCURHandler[] = { {&_swigt__p_wxCURHandler, 0, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxCURHandler, 0, 0},{0, 0, 0, 0}};
55999 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56000 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56001 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56002 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56003 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56004 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
56005 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56006 static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0},{0, 0, 0, 0}};
56007 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56008 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56009 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56010 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56011 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56012 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56013 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56014 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56015 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56016 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56017 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56018 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56019 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
56020 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56021 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56022 static swig_cast_info _swigc__p_wxFileSystemHandler[] = { {&_swigt__p_wxFileSystemHandler, 0, 0, 0}, {&_swigt__p_wxPyFileSystemHandler, _p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler, 0, 0}, {&_swigt__p_wxInternetFSHandler, _p_wxInternetFSHandlerTo_p_wxFileSystemHandler, 0, 0}, {&_swigt__p_wxZipFSHandler, _p_wxZipFSHandlerTo_p_wxFileSystemHandler, 0, 0}, {&_swigt__p_wxMemoryFSHandler, _p_wxMemoryFSHandlerTo_p_wxFileSystemHandler, 0, 0},{0, 0, 0, 0}};
56023 static swig_cast_info _swigc__p_wxFlexGridSizer[] = { {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxFlexGridSizer, 0, 0}, {&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
56024 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56025 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56026 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56027 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56028 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56029 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56030 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56031 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56032 static swig_cast_info _swigc__p_wxGridSizer[] = { {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxGridSizer, 0, 0}, {&_swigt__p_wxGridSizer, 0, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxGridSizer, 0, 0},{0, 0, 0, 0}};
56033 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56034 static swig_cast_info _swigc__p_wxICOHandler[] = { {&_swigt__p_wxICOHandler, 0, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxICOHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxICOHandler, 0, 0},{0, 0, 0, 0}};
56035 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56036 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56037 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56038 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
56039 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56040 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56041 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56042 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56043 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56044 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56045 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56046 static swig_cast_info _swigc__p_wxItemContainer[] = { {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxItemContainer, 0, 0}, {&_swigt__p_wxItemContainer, 0, 0, 0},{0, 0, 0, 0}};
56047 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56048 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56049 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56050 static swig_cast_info _swigc__p_wxLayoutDirection[] = { {&_swigt__p_wxLayoutDirection, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56052 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56053 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56054 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56055 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56056 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56057 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56058 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56059 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56060 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56061 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56062 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56063 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56064 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56066 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56067 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56068 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56069 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56070 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56071 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56072 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56073 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56074 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56075 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56078 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56079 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56080 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56081 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56082 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56083 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56084 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56085 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56086 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56087 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56088 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56089 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56090 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56091 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56092 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56093 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56094 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56095 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56096 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56097 static swig_cast_info _swigc__p_wxSizer[] = { {&_swigt__p_wxSizer, 0, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxSizer, 0, 0},{0, 0, 0, 0}};
56098 static swig_cast_info _swigc__p_wxSizerItem[] = { {&_swigt__p_wxSizerItem, 0, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxSizerItem, 0, 0},{0, 0, 0, 0}};
56099 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56100 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56101 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56102 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56103 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56104 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56105 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56106 static swig_cast_info _swigc__p_wxValidator[] = { {&_swigt__p_wxValidator, 0, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxValidator, 0, 0},{0, 0, 0, 0}};
56107 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56108 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
56109 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56110 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56111 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56112 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56113
56114 static swig_cast_info *swig_cast_initial[] = {
56115 _swigc__p_buffer,
56116 _swigc__p_char,
56117 _swigc__p_form_ops_t,
56118 _swigc__p_int,
56119 _swigc__p_long,
56120 _swigc__p_unsigned_char,
56121 _swigc__p_unsigned_int,
56122 _swigc__p_unsigned_long,
56123 _swigc__p_wxANIHandler,
56124 _swigc__p_wxAcceleratorEntry,
56125 _swigc__p_wxAcceleratorTable,
56126 _swigc__p_wxActivateEvent,
56127 _swigc__p_wxAppTraits,
56128 _swigc__p_wxArrayString,
56129 _swigc__p_wxBMPHandler,
56130 _swigc__p_wxBitmap,
56131 _swigc__p_wxBoxSizer,
56132 _swigc__p_wxButton,
56133 _swigc__p_wxCURHandler,
56134 _swigc__p_wxCaret,
56135 _swigc__p_wxChildFocusEvent,
56136 _swigc__p_wxClipboardTextEvent,
56137 _swigc__p_wxCloseEvent,
56138 _swigc__p_wxColour,
56139 _swigc__p_wxCommandEvent,
56140 _swigc__p_wxContextMenuEvent,
56141 _swigc__p_wxControl,
56142 _swigc__p_wxControlWithItems,
56143 _swigc__p_wxCursor,
56144 _swigc__p_wxDC,
56145 _swigc__p_wxDateEvent,
56146 _swigc__p_wxDateTime,
56147 _swigc__p_wxDisplayChangedEvent,
56148 _swigc__p_wxDropFilesEvent,
56149 _swigc__p_wxDuplexMode,
56150 _swigc__p_wxEraseEvent,
56151 _swigc__p_wxEvent,
56152 _swigc__p_wxEventLoop,
56153 _swigc__p_wxEventLoopActivator,
56154 _swigc__p_wxEvtHandler,
56155 _swigc__p_wxFSFile,
56156 _swigc__p_wxFileSystem,
56157 _swigc__p_wxFileSystemHandler,
56158 _swigc__p_wxFlexGridSizer,
56159 _swigc__p_wxFocusEvent,
56160 _swigc__p_wxFont,
56161 _swigc__p_wxFrame,
56162 _swigc__p_wxGBPosition,
56163 _swigc__p_wxGBSizerItem,
56164 _swigc__p_wxGBSpan,
56165 _swigc__p_wxGIFHandler,
56166 _swigc__p_wxGridBagSizer,
56167 _swigc__p_wxGridSizer,
56168 _swigc__p_wxHelpEvent__Origin,
56169 _swigc__p_wxICOHandler,
56170 _swigc__p_wxIconizeEvent,
56171 _swigc__p_wxIdleEvent,
56172 _swigc__p_wxImage,
56173 _swigc__p_wxImageHandler,
56174 _swigc__p_wxImageHistogram,
56175 _swigc__p_wxImage_HSVValue,
56176 _swigc__p_wxImage_RGBValue,
56177 _swigc__p_wxIndividualLayoutConstraint,
56178 _swigc__p_wxInitDialogEvent,
56179 _swigc__p_wxInputStream,
56180 _swigc__p_wxInternetFSHandler,
56181 _swigc__p_wxItemContainer,
56182 _swigc__p_wxJPEGHandler,
56183 _swigc__p_wxKeyEvent,
56184 _swigc__p_wxLayoutConstraints,
56185 _swigc__p_wxLayoutDirection,
56186 _swigc__p_wxMaximizeEvent,
56187 _swigc__p_wxMemoryFSHandler,
56188 _swigc__p_wxMenu,
56189 _swigc__p_wxMenuBar,
56190 _swigc__p_wxMenuBarBase,
56191 _swigc__p_wxMenuEvent,
56192 _swigc__p_wxMenuItem,
56193 _swigc__p_wxMouseCaptureChangedEvent,
56194 _swigc__p_wxMouseCaptureLostEvent,
56195 _swigc__p_wxMouseEvent,
56196 _swigc__p_wxMoveEvent,
56197 _swigc__p_wxNavigationKeyEvent,
56198 _swigc__p_wxNcPaintEvent,
56199 _swigc__p_wxNotifyEvent,
56200 _swigc__p_wxObject,
56201 _swigc__p_wxOutputStream,
56202 _swigc__p_wxPCXHandler,
56203 _swigc__p_wxPNGHandler,
56204 _swigc__p_wxPNMHandler,
56205 _swigc__p_wxPaintEvent,
56206 _swigc__p_wxPaletteChangedEvent,
56207 _swigc__p_wxPaperSize,
56208 _swigc__p_wxPoint,
56209 _swigc__p_wxPoint2D,
56210 _swigc__p_wxPropagateOnce,
56211 _swigc__p_wxPropagationDisabler,
56212 _swigc__p_wxPyApp,
56213 _swigc__p_wxPyCommandEvent,
56214 _swigc__p_wxPyDropTarget,
56215 _swigc__p_wxPyEvent,
56216 _swigc__p_wxPyFileSystemHandler,
56217 _swigc__p_wxPyImageHandler,
56218 _swigc__p_wxPyInputStream,
56219 _swigc__p_wxPySizer,
56220 _swigc__p_wxPyValidator,
56221 _swigc__p_wxQuantize,
56222 _swigc__p_wxQueryNewPaletteEvent,
56223 _swigc__p_wxRealPoint,
56224 _swigc__p_wxRect,
56225 _swigc__p_wxRegion,
56226 _swigc__p_wxScrollEvent,
56227 _swigc__p_wxScrollWinEvent,
56228 _swigc__p_wxSetCursorEvent,
56229 _swigc__p_wxShowEvent,
56230 _swigc__p_wxSize,
56231 _swigc__p_wxSizeEvent,
56232 _swigc__p_wxSizer,
56233 _swigc__p_wxSizerItem,
56234 _swigc__p_wxStaticBox,
56235 _swigc__p_wxStaticBoxSizer,
56236 _swigc__p_wxStdDialogButtonSizer,
56237 _swigc__p_wxSysColourChangedEvent,
56238 _swigc__p_wxTIFFHandler,
56239 _swigc__p_wxToolTip,
56240 _swigc__p_wxUpdateUIEvent,
56241 _swigc__p_wxValidator,
56242 _swigc__p_wxVisualAttributes,
56243 _swigc__p_wxWindow,
56244 _swigc__p_wxWindowCreateEvent,
56245 _swigc__p_wxWindowDestroyEvent,
56246 _swigc__p_wxXPMHandler,
56247 _swigc__p_wxZipFSHandler,
56248 };
56249
56250
56251 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56252
56253 static swig_const_info swig_const_table[] = {
56254 {0, 0, 0, 0.0, 0, 0}};
56255
56256 #ifdef __cplusplus
56257 }
56258 #endif
56259 /* -----------------------------------------------------------------------------
56260 * Type initialization:
56261 * This problem is tough by the requirement that no dynamic
56262 * memory is used. Also, since swig_type_info structures store pointers to
56263 * swig_cast_info structures and swig_cast_info structures store pointers back
56264 * to swig_type_info structures, we need some lookup code at initialization.
56265 * The idea is that swig generates all the structures that are needed.
56266 * The runtime then collects these partially filled structures.
56267 * The SWIG_InitializeModule function takes these initial arrays out of
56268 * swig_module, and does all the lookup, filling in the swig_module.types
56269 * array with the correct data and linking the correct swig_cast_info
56270 * structures together.
56271 *
56272 * The generated swig_type_info structures are assigned staticly to an initial
56273 * array. We just loop though that array, and handle each type individually.
56274 * First we lookup if this type has been already loaded, and if so, use the
56275 * loaded structure instead of the generated one. Then we have to fill in the
56276 * cast linked list. The cast data is initially stored in something like a
56277 * two-dimensional array. Each row corresponds to a type (there are the same
56278 * number of rows as there are in the swig_type_initial array). Each entry in
56279 * a column is one of the swig_cast_info structures for that type.
56280 * The cast_initial array is actually an array of arrays, because each row has
56281 * a variable number of columns. So to actually build the cast linked list,
56282 * we find the array of casts associated with the type, and loop through it
56283 * adding the casts to the list. The one last trick we need to do is making
56284 * sure the type pointer in the swig_cast_info struct is correct.
56285 *
56286 * First off, we lookup the cast->type name to see if it is already loaded.
56287 * There are three cases to handle:
56288 * 1) If the cast->type has already been loaded AND the type we are adding
56289 * casting info to has not been loaded (it is in this module), THEN we
56290 * replace the cast->type pointer with the type pointer that has already
56291 * been loaded.
56292 * 2) If BOTH types (the one we are adding casting info to, and the
56293 * cast->type) are loaded, THEN the cast info has already been loaded by
56294 * the previous module so we just ignore it.
56295 * 3) Finally, if cast->type has not already been loaded, then we add that
56296 * swig_cast_info to the linked list (because the cast->type) pointer will
56297 * be correct.
56298 * ----------------------------------------------------------------------------- */
56299
56300 #ifdef __cplusplus
56301 extern "C" {
56302 #if 0
56303 } /* c-mode */
56304 #endif
56305 #endif
56306
56307 #if 0
56308 #define SWIGRUNTIME_DEBUG
56309 #endif
56310
56311 SWIGRUNTIME void
56312 SWIG_InitializeModule(void *clientdata) {
56313 size_t i;
56314 swig_module_info *module_head;
56315 static int init_run = 0;
56316
56317 clientdata = clientdata;
56318
56319 if (init_run) return;
56320 init_run = 1;
56321
56322 /* Initialize the swig_module */
56323 swig_module.type_initial = swig_type_initial;
56324 swig_module.cast_initial = swig_cast_initial;
56325
56326 /* Try and load any already created modules */
56327 module_head = SWIG_GetModule(clientdata);
56328 if (module_head) {
56329 swig_module.next = module_head->next;
56330 module_head->next = &swig_module;
56331 } else {
56332 /* This is the first module loaded */
56333 swig_module.next = &swig_module;
56334 SWIG_SetModule(clientdata, &swig_module);
56335 }
56336
56337 /* Now work on filling in swig_module.types */
56338 #ifdef SWIGRUNTIME_DEBUG
56339 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56340 #endif
56341 for (i = 0; i < swig_module.size; ++i) {
56342 swig_type_info *type = 0;
56343 swig_type_info *ret;
56344 swig_cast_info *cast;
56345
56346 #ifdef SWIGRUNTIME_DEBUG
56347 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56348 #endif
56349
56350 /* if there is another module already loaded */
56351 if (swig_module.next != &swig_module) {
56352 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56353 }
56354 if (type) {
56355 /* Overwrite clientdata field */
56356 #ifdef SWIGRUNTIME_DEBUG
56357 printf("SWIG_InitializeModule: found type %s\n", type->name);
56358 #endif
56359 if (swig_module.type_initial[i]->clientdata) {
56360 type->clientdata = swig_module.type_initial[i]->clientdata;
56361 #ifdef SWIGRUNTIME_DEBUG
56362 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56363 #endif
56364 }
56365 } else {
56366 type = swig_module.type_initial[i];
56367 }
56368
56369 /* Insert casting types */
56370 cast = swig_module.cast_initial[i];
56371 while (cast->type) {
56372 /* Don't need to add information already in the list */
56373 ret = 0;
56374 #ifdef SWIGRUNTIME_DEBUG
56375 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56376 #endif
56377 if (swig_module.next != &swig_module) {
56378 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56379 #ifdef SWIGRUNTIME_DEBUG
56380 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56381 #endif
56382 }
56383 if (ret) {
56384 if (type == swig_module.type_initial[i]) {
56385 #ifdef SWIGRUNTIME_DEBUG
56386 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56387 #endif
56388 cast->type = ret;
56389 ret = 0;
56390 } else {
56391 /* Check for casting already in the list */
56392 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56393 #ifdef SWIGRUNTIME_DEBUG
56394 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56395 #endif
56396 if (!ocast) ret = 0;
56397 }
56398 }
56399
56400 if (!ret) {
56401 #ifdef SWIGRUNTIME_DEBUG
56402 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56403 #endif
56404 if (type->cast) {
56405 type->cast->prev = cast;
56406 cast->next = type->cast;
56407 }
56408 type->cast = cast;
56409 }
56410 cast++;
56411 }
56412 /* Set entry in modules->types array equal to the type */
56413 swig_module.types[i] = type;
56414 }
56415 swig_module.types[i] = 0;
56416
56417 #ifdef SWIGRUNTIME_DEBUG
56418 printf("**** SWIG_InitializeModule: Cast List ******\n");
56419 for (i = 0; i < swig_module.size; ++i) {
56420 int j = 0;
56421 swig_cast_info *cast = swig_module.cast_initial[i];
56422 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56423 while (cast->type) {
56424 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56425 cast++;
56426 ++j;
56427 }
56428 printf("---- Total casts: %d\n",j);
56429 }
56430 printf("**** SWIG_InitializeModule: Cast List ******\n");
56431 #endif
56432 }
56433
56434 /* This function will propagate the clientdata field of type to
56435 * any new swig_type_info structures that have been added into the list
56436 * of equivalent types. It is like calling
56437 * SWIG_TypeClientData(type, clientdata) a second time.
56438 */
56439 SWIGRUNTIME void
56440 SWIG_PropagateClientData(void) {
56441 size_t i;
56442 swig_cast_info *equiv;
56443 static int init_run = 0;
56444
56445 if (init_run) return;
56446 init_run = 1;
56447
56448 for (i = 0; i < swig_module.size; i++) {
56449 if (swig_module.types[i]->clientdata) {
56450 equiv = swig_module.types[i]->cast;
56451 while (equiv) {
56452 if (!equiv->converter) {
56453 if (equiv->type && !equiv->type->clientdata)
56454 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56455 }
56456 equiv = equiv->next;
56457 }
56458 }
56459 }
56460 }
56461
56462 #ifdef __cplusplus
56463 #if 0
56464 {
56465 /* c-mode */
56466 #endif
56467 }
56468 #endif
56469
56470
56471
56472 #ifdef __cplusplus
56473 extern "C" {
56474 #endif
56475
56476 /* Python-specific SWIG API */
56477 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56478 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56479 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56480
56481 /* -----------------------------------------------------------------------------
56482 * global variable support code.
56483 * ----------------------------------------------------------------------------- */
56484
56485 typedef struct swig_globalvar {
56486 char *name; /* Name of global variable */
56487 PyObject *(*get_attr)(void); /* Return the current value */
56488 int (*set_attr)(PyObject *); /* Set the value */
56489 struct swig_globalvar *next;
56490 } swig_globalvar;
56491
56492 typedef struct swig_varlinkobject {
56493 PyObject_HEAD
56494 swig_globalvar *vars;
56495 } swig_varlinkobject;
56496
56497 SWIGINTERN PyObject *
56498 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56499 return PyString_FromString("<Swig global variables>");
56500 }
56501
56502 SWIGINTERN PyObject *
56503 swig_varlink_str(swig_varlinkobject *v) {
56504 PyObject *str = PyString_FromString("(");
56505 swig_globalvar *var;
56506 for (var = v->vars; var; var=var->next) {
56507 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56508 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56509 }
56510 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56511 return str;
56512 }
56513
56514 SWIGINTERN int
56515 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56516 PyObject *str = swig_varlink_str(v);
56517 fprintf(fp,"Swig global variables ");
56518 fprintf(fp,"%s\n", PyString_AsString(str));
56519 Py_DECREF(str);
56520 return 0;
56521 }
56522
56523 SWIGINTERN void
56524 swig_varlink_dealloc(swig_varlinkobject *v) {
56525 swig_globalvar *var = v->vars;
56526 while (var) {
56527 swig_globalvar *n = var->next;
56528 free(var->name);
56529 free(var);
56530 var = n;
56531 }
56532 }
56533
56534 SWIGINTERN PyObject *
56535 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56536 PyObject *res = NULL;
56537 swig_globalvar *var = v->vars;
56538 while (var) {
56539 if (strcmp(var->name,n) == 0) {
56540 res = (*var->get_attr)();
56541 break;
56542 }
56543 var = var->next;
56544 }
56545 if (res == NULL && !PyErr_Occurred()) {
56546 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56547 }
56548 return res;
56549 }
56550
56551 SWIGINTERN int
56552 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56553 int res = 1;
56554 swig_globalvar *var = v->vars;
56555 while (var) {
56556 if (strcmp(var->name,n) == 0) {
56557 res = (*var->set_attr)(p);
56558 break;
56559 }
56560 var = var->next;
56561 }
56562 if (res == 1 && !PyErr_Occurred()) {
56563 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56564 }
56565 return res;
56566 }
56567
56568 SWIGINTERN PyTypeObject*
56569 swig_varlink_type(void) {
56570 static char varlink__doc__[] = "Swig var link object";
56571 static PyTypeObject varlink_type;
56572 static int type_init = 0;
56573 if (!type_init) {
56574 const PyTypeObject tmp
56575 = {
56576 PyObject_HEAD_INIT(NULL)
56577 0, /* Number of items in variable part (ob_size) */
56578 (char *)"swigvarlink", /* Type name (tp_name) */
56579 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56580 0, /* Itemsize (tp_itemsize) */
56581 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56582 (printfunc) swig_varlink_print, /* Print (tp_print) */
56583 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56584 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56585 0, /* tp_compare */
56586 (reprfunc) swig_varlink_repr, /* tp_repr */
56587 0, /* tp_as_number */
56588 0, /* tp_as_sequence */
56589 0, /* tp_as_mapping */
56590 0, /* tp_hash */
56591 0, /* tp_call */
56592 (reprfunc)swig_varlink_str, /* tp_str */
56593 0, /* tp_getattro */
56594 0, /* tp_setattro */
56595 0, /* tp_as_buffer */
56596 0, /* tp_flags */
56597 varlink__doc__, /* tp_doc */
56598 0, /* tp_traverse */
56599 0, /* tp_clear */
56600 0, /* tp_richcompare */
56601 0, /* tp_weaklistoffset */
56602 #if PY_VERSION_HEX >= 0x02020000
56603 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56604 #endif
56605 #if PY_VERSION_HEX >= 0x02030000
56606 0, /* tp_del */
56607 #endif
56608 #ifdef COUNT_ALLOCS
56609 0,0,0,0 /* tp_alloc -> tp_next */
56610 #endif
56611 };
56612 varlink_type = tmp;
56613 varlink_type.ob_type = &PyType_Type;
56614 type_init = 1;
56615 }
56616 return &varlink_type;
56617 }
56618
56619 /* Create a variable linking object for use later */
56620 SWIGINTERN PyObject *
56621 SWIG_Python_newvarlink(void) {
56622 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56623 if (result) {
56624 result->vars = 0;
56625 }
56626 return ((PyObject*) result);
56627 }
56628
56629 SWIGINTERN void
56630 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56631 swig_varlinkobject *v = (swig_varlinkobject *) p;
56632 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56633 if (gv) {
56634 size_t size = strlen(name)+1;
56635 gv->name = (char *)malloc(size);
56636 if (gv->name) {
56637 strncpy(gv->name,name,size);
56638 gv->get_attr = get_attr;
56639 gv->set_attr = set_attr;
56640 gv->next = v->vars;
56641 }
56642 }
56643 v->vars = gv;
56644 }
56645
56646 SWIGINTERN PyObject *
56647 SWIG_globals() {
56648 static PyObject *_SWIG_globals = 0;
56649 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56650 return _SWIG_globals;
56651 }
56652
56653 /* -----------------------------------------------------------------------------
56654 * constants/methods manipulation
56655 * ----------------------------------------------------------------------------- */
56656
56657 /* Install Constants */
56658 SWIGINTERN void
56659 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56660 PyObject *obj = 0;
56661 size_t i;
56662 for (i = 0; constants[i].type; ++i) {
56663 switch(constants[i].type) {
56664 case SWIG_PY_POINTER:
56665 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56666 break;
56667 case SWIG_PY_BINARY:
56668 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56669 break;
56670 default:
56671 obj = 0;
56672 break;
56673 }
56674 if (obj) {
56675 PyDict_SetItemString(d, constants[i].name, obj);
56676 Py_DECREF(obj);
56677 }
56678 }
56679 }
56680
56681 /* -----------------------------------------------------------------------------*/
56682 /* Fix SwigMethods to carry the callback ptrs when needed */
56683 /* -----------------------------------------------------------------------------*/
56684
56685 SWIGINTERN void
56686 SWIG_Python_FixMethods(PyMethodDef *methods,
56687 swig_const_info *const_table,
56688 swig_type_info **types,
56689 swig_type_info **types_initial) {
56690 size_t i;
56691 for (i = 0; methods[i].ml_name; ++i) {
56692 const char *c = methods[i].ml_doc;
56693 if (c && (c = strstr(c, "swig_ptr: "))) {
56694 int j;
56695 swig_const_info *ci = 0;
56696 const char *name = c + 10;
56697 for (j = 0; const_table[j].type; ++j) {
56698 if (strncmp(const_table[j].name, name,
56699 strlen(const_table[j].name)) == 0) {
56700 ci = &(const_table[j]);
56701 break;
56702 }
56703 }
56704 if (ci) {
56705 size_t shift = (ci->ptype) - types;
56706 swig_type_info *ty = types_initial[shift];
56707 size_t ldoc = (c - methods[i].ml_doc);
56708 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56709 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56710 if (ndoc) {
56711 char *buff = ndoc;
56712 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56713 if (ptr) {
56714 strncpy(buff, methods[i].ml_doc, ldoc);
56715 buff += ldoc;
56716 strncpy(buff, "swig_ptr: ", 10);
56717 buff += 10;
56718 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56719 methods[i].ml_doc = ndoc;
56720 }
56721 }
56722 }
56723 }
56724 }
56725 }
56726
56727 #ifdef __cplusplus
56728 }
56729 #endif
56730
56731 /* -----------------------------------------------------------------------------*
56732 * Partial Init method
56733 * -----------------------------------------------------------------------------*/
56734
56735 #ifdef __cplusplus
56736 extern "C"
56737 #endif
56738 SWIGEXPORT void SWIG_init(void) {
56739 PyObject *m, *d;
56740
56741 /* Fix SwigMethods to carry the callback ptrs when needed */
56742 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56743
56744 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56745 d = PyModule_GetDict(m);
56746
56747 SWIG_InitializeModule(0);
56748 SWIG_InstallConstants(d,swig_const_table);
56749
56750
56751
56752 #ifndef wxPyUSE_EXPORT
56753 // Make our API structure a CObject so other modules can import it
56754 // from this module.
56755 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56756 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56757 Py_XDECREF(cobj);
56758 #endif
56759
56760 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56761 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56762 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56763 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56764 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56765 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56766 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56767 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56768 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56769 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56770 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56771 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56772 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56773 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56774 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56775 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56776 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56777 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56778 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56779 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56780 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56781 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56782 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56783 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56784 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56785 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56786 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56787 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56788 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56789 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56790 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56791 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56792 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56793 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56794 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56795 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56796 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56797 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56798 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56799 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56800 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56801 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56802 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56803 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56804 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56805 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56806 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56807 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56808 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56809 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56810 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56811 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56812 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56813 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56814 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56815 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56816 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56817 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56818 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56819 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56820 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56821 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56822 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56823 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56824 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56825 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56826 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56827 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56828 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56829 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56830 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56831 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56832 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56833 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56834 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56835 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56836 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56837 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56838 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56839 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56840 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56841 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56842 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56843 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56844 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56845 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56846 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56847 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56848 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56849 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56850 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56851 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56852 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56853 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56854 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56855 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56856 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56857 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56858 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56859 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56860 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56861 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56862 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56863 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56864 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56865 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56866 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56867 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56868 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56869 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56870 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56871 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56872 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56873 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56874 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56875 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56876 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56877 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56878 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56879 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56880 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56881 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56882 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56883 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56884 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56885 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56886 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56887 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56888 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56889 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56890 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56891 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56892 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56893 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56894 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56895 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56896 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56897 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56898 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56899 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56900 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56901 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56902 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56903 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56904 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56905 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56906 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56907 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56908 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56909 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56910 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56911 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56912 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56913 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56914 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56915 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56916 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56917 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56918 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56919 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56920 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56921 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56922 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56923 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56924 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56925 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56926 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56927 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56928 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56929 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56930 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56931 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56932 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56933 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56934 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56935 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56936 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56937 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56938 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56939 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56940 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56941 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56942 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56943 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56944 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56945 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56946 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56947 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56948 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56949 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56950 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56951 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56952 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56953 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56954 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56955 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56956 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56957 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56958 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56959 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56960 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56961 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56962 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56963 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56964 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56965 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56966 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56967 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56968 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56969 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56970 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56971 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56972 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56973 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56974 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56975 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56976 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56977 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56978 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56979 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56980 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56981 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56982 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56983 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56984 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56985 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56986 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56987 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56988 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56989 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56990 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56991 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56992 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56993 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56994 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56995 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56996 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56997 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56998 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56999 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57000 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57001 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57002 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57003 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57004 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57005 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57006 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57007 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57008 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57009 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57010 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57011 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57012 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57013 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57014 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57015 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57016 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57017 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57018 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57019 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57020 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57021 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57022 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57023 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57024 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57025 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57026 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57027 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57028 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57029 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57030 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57031 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57032 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57033 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57034 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57035 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57036 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57037 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57038 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57039 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57040 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57041 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57042 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57043 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57044 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57045 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57046 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57047 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57048 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57049 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57050 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57051 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57052 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57053 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57054 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57055 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57056 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57057 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57058 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57059 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57060 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57061 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57062 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57063 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57064 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57065 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57066 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57067 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57068 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57069 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57070 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57071 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57072 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57073 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57074 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57075 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57076 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57077 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57078 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57079 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57080 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57081 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57082 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57083 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57084 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57085 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57086 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57087 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57088 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57089 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57090 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57091 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57092 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57093 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57094 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57095 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57096 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57097 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57098 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57099 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57100 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57101 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57102 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57103 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57104 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57105 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57106 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57107 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57108 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57109 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57110 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57111 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57112 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57113 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57114 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57115 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57116 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57117 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57118 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57119 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57120 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57121 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57122 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57123 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57124 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57125 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57126 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57127 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57128 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57129 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57130 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57131 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57132 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57133 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57134 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57135 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57136 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57137 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57138 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57139 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57140 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57141 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57142 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57143 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57144 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57145 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57146 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57147 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57148 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57149 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57150 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57151 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57152 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57153 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57154 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57155 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57156 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57157 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57158 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57159 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57160 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57161 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57162 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57163 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57164 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57165 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57166 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57167 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57168 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57169 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57170 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57171 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57172 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57173 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57174 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57175 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57176 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57177 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57178 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57179 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57180 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57181 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57182 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57183 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57184 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57185 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57186 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57187 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57188 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57189 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57190 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57191 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57192 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57193 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57194 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57195 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57196 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57197 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57198 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57199 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57200 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57201 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57202 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57203 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57204 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57205 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57206 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57207 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57208 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57209 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57210 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57211 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57212 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57213 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57214 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57215 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57216 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57217 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57218 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57219 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57220 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57221 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57222 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57223 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57224 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57225 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57226 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57227 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57228 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57229 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57230 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57231 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57232 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57233 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57234 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57235 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57236 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57237 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57238 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57239 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57240 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57241 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57242 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57243 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57244 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57245 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57246 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57247 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57248 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57249 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57250 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57251 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57252 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57253 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57254 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57255 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57256 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57257 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57258 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57259 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57260 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57261 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57262 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57263 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57264 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57265 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57266 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57267 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57268 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57269 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57270 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57271 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57272 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57273 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57274 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57275 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57276 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57277 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57278 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57279 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57280 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57281 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57282 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57283 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57284 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57285 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57286 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57287 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57288 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57289 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57290 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57291 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57292 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57293 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57294 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57295 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57296 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57297 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57298 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57299 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57300 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57301 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57302 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57303 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57304 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57305 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57306 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57307 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57308 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57309 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57310 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57311 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57312 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57313 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57314 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57315 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57316 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57317 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57318 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57319 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57320 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57321 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57322 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57323 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57324 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57325 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57326 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57327 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57328 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57329 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57330 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57331 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57332 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57333 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57334 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57335 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57336 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57337 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57338 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57339 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57340 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57341 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57342 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57343 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57344 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57345 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57346 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57347 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57348 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57349 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57350 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57351 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57352 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57353 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57354 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57355 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57356 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57357 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57358 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57359 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57360 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57361 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57362 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57363 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57364 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57365 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57366 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57367 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57368 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57369 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57370 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57371 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57372 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57373 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57374 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57375 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57376 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57377 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57378 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57379 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57380 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57381 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57382 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57383 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57384 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57385 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57386 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57387 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57388 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57389 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57390 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57391 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57392 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57393 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57394 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57395 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57396 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57397 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57398 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57399 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57400 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57401 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57402 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57403 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57404 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57405 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57406 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57407 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57408 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57409 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57410 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57411 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57412 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57413 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57414 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57415 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57416
57417 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57418
57419
57420 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57421
57422 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57423 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57424 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57425 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57426 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57427 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57428 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57429 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57430 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57431 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57432 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57433 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57434 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57435 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57436 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57437 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57438 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57439 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57440 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57441 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57442 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57443 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57444 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57445 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57446 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57447 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57448 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57449 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57450 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57451 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57452 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57453 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57454 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57455 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57456 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57457 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57458 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57459 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57460 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57461 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57462 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57463 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57464 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57465 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57466 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57467 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57468 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57469 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57470 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57471 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57472 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57473 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57474 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57475 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57476 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57477 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57478 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57479 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57480 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57481 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57482 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57483 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57484 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57485 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57486 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57487 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57488 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57489 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57490 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57491 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57492 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57493 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57494 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57495 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57496 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57497 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57498 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57499 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57500 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57501 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57502 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57503 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57504 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57505 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57506 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57507 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57508 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57509 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57510 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57511 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57512 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57513 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57514 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57515 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57516 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57517 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57518 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57519 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57520 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57521 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57522 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57523 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57524 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57525 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57526 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57527 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57528 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57529 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57530 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57531 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57532 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57533 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57534 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57535 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57536 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57537 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57538 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57539 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57540 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57541 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57542 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57543 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57544 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57545 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57546 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57547 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57548 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57549 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57550 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57551 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57552 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57553 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57554 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57555 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57556 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57557 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57558 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57559 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57560 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57561 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57562 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57563 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57564 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57565 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57566 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57567 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57568 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57569 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57570 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57571 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57572 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57573 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57574 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57575 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57576 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57577 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57578 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57579 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57580 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57581 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57582 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57583 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57584 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57585 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57586 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57587 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57588 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57589 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57590 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57591 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57592 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57593 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57594 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57595 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57596 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57597 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57598 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57599 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57600 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57601 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57602 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57603 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57604 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57605 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57606 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57607 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57608 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57609 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57610 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57611 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57612 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57613 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57614 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57615 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57616 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57617 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57618 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57619 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57620 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57621 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57622 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57623 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57624 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57625 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57626 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57627 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57628 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57629 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57630 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57631 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57632 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57633 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57634
57635 // Initialize threading, some globals and such
57636 __wxPyPreStart(d);
57637
57638
57639 // Although these are defined in __version__ they need to be here too so
57640 // that an assert can be done to ensure that the wxPython and the wxWindows
57641 // versions match.
57642 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57643 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57644 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57645
57646 }
57647
wxWidgets (Impactor)